@stll/folio-cli 0.5.3 → 0.5.4

package/dist/batch-operations.d.ts

@@ -4,13 +4,13 @@ import { Result } from "better-result";
 import { FolioAgentBridge } from "@stll/folio-agents/bridge";
 import { FolioAgentToolOptions } from "@stll/folio-agents/suggest-changes-options";
 //#region src/batch-operations.d.ts
-declare const BATCH_OPERATION_TYPES: readonly ["replaceAll", "addComment"];
+export declare const BATCH_OPERATION_TYPES: readonly ["replaceAll", "addComment"];
 /**
  * `suggest_changes`' arguments with the batch operations added to the
  * operation schema: their types in the `type` enum and their extra fields.
  */
-declare const withBatchOperations: (schema: JsonObjectSchema) => JsonObjectSchema;
-type ExpandedBatch = {
+export declare const withBatchOperations: (schema: JsonObjectSchema) => JsonObjectSchema;
+export type ExpandedBatch = {
   operations: unknown[];
   /** Options the expanded batch needs from `suggest_changes`. */
   options: FolioAgentToolOptions;
@@ -24,6 +24,5 @@ type ExpandedBatch = {
  * Expand the batch operations of a `suggest_changes` call against the
  * document the bridge holds. Contract operations pass through unchanged.
  */
-declare const expandBatchOperations: (operations: unknown, bridge: FolioAgentBridge) => Result<ExpandedBatch, FolioCliError>;
-//#endregion
-export { BATCH_OPERATION_TYPES, ExpandedBatch, expandBatchOperations, withBatchOperations };
+export declare const expandBatchOperations: (operations: unknown, bridge: FolioAgentBridge) => Result<ExpandedBatch, FolioCliError>;
+//#endregion

package/dist/cli.d.ts

@@ -1,7 +1,7 @@
 import { Readable, Writable } from "node:stream";
 //#region src/cli.d.ts
 /** The process surface the command line reads from and writes to. */
-type FolioCliIo = {
+export type FolioCliIo = {
   stdout: (text: string) => void;
   stderr: (text: string) => void;
   readStdin: () => Promise<string>;
@@ -20,6 +20,5 @@ type FolioCliIo = {
   untilInterrupted?: () => Promise<void>;
 };
 /** Run `folio` with the given arguments (without the executable); resolves to the exit code. */
-declare const runFolioCli: (argv: readonly string[], io: FolioCliIo) => Promise<number>;
-//#endregion
-export { FolioCliIo, runFolioCli };
+export declare const runFolioCli: (argv: readonly string[], io: FolioCliIo) => Promise<number>;
+//#endregion

package/dist/cli.js

@@ -269,8 +269,9 @@ const requestedFormat = (argv, io) => {
 	return isOutputFormat(value) ? value : defaultFormat(io);
 };
 const emit = ({ io, format, tool, 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
 	});

package/dist/document.d.ts

@@ -4,10 +4,10 @@ import { Result } from "better-result";
 import { FolioDocxReviewer } from "@stll/folio-core/server";
 //#region src/document.d.ts
 /** Largest `.docx` the CLI opens; larger inputs are refused before reading. */
-declare const MAX_DOCUMENT_BYTES: number;
-declare const isFileVersion: (value: unknown) => value is string;
+export declare const MAX_DOCUMENT_BYTES: number;
+export declare const isFileVersion: (value: unknown) => value is string;
 /** The bytes of one input file and the version they hash to. */
-type LoadedFile = {
+export type LoadedFile = {
   /** Real path (symlinks resolved) the bytes were read from. */
   path: string;
   bytes: Uint8Array<ArrayBuffer>;
@@ -22,7 +22,7 @@ type LoadedFile = {
  * that takes a document reads it here, so none can treat an archive without
  * a main document part as an empty document.
  */
-declare const readDocumentFile: (inputPath: string) => Promise<Result<LoadedFile, FolioCliError>>;
+export declare const readDocumentFile: (inputPath: string) => Promise<Result<LoadedFile, FolioCliError>>;
 /**
  * Where a block id comes from. `package` ids are the paragraph's own
  * `w14:paraId` in the file; `synthetic` ids were minted for a paragraph the
@@ -30,9 +30,9 @@ declare const readDocumentFile: (inputPath: string) => Promise<Result<LoadedFile
  * first change written to such a file stores them, so from then on they are
  * the package's own.
  */
-type FolioBlockIdSource = "package" | "synthetic";
+export type FolioBlockIdSource = "package" | "synthetic";
 /** A reviewer over one file and which of its block ids the file itself carries. */
-type OpenedDocument = {
+export type OpenedDocument = {
   reviewer: FolioDocxReviewer;
   /** Ids minted for paragraphs without one; `null` when none could be minted up front. */
   mintedIds: ReadonlySet<string> | null;
@@ -41,8 +41,8 @@ type OpenedDocument = {
  * Parse a loaded file into a headless reviewer. `author` is required for a
  * reviewer that will author changes; reads pass none and never write.
  */
-declare const openReviewer: (file: LoadedFile, author?: string) => Promise<Result<OpenedDocument, FolioCliError>>;
+export declare const openReviewer: (file: LoadedFile, author?: string) => Promise<Result<OpenedDocument, FolioCliError>>;
 /** Refuse when the caller's expected version is not the file's current one. */
-declare const checkExpectedVersion: (file: LoadedFile, expected: string | undefined) => Result<void, FolioCliError>;
+export declare const checkExpectedVersion: (file: LoadedFile, expected: string | undefined) => Result<void, FolioCliError>;
 //#endregion
-export { type FileIdentity, FolioBlockIdSource, LoadedFile, MAX_DOCUMENT_BYTES, NO_FOLLOW, OpenedDocument, checkExpectedVersion, errnoCode, fileVersionOf, isFileVersion, openReviewer, readDocumentFile, sameFile };
+export { type FileIdentity, NO_FOLLOW, errnoCode, fileVersionOf, sameFile };

package/dist/document.js

@@ -8,7 +8,7 @@ import path from "node:path";
 import { FolioDocxReviewer, ensureParaIds } from "@stll/folio-core/server";
 //#region src/document.ts
 /** Largest `.docx` the CLI opens; larger inputs are refused before reading. */
-const MAX_DOCUMENT_BYTES = 64 * 1024 * 1024;
+const MAX_DOCUMENT_BYTES = 67108864;
 const FILE_VERSION_PATTERN = /^[0-9a-f]{64}$/u;
 const isFileVersion = (value) => typeof value === "string" && FILE_VERSION_PATTERN.test(value);
 const describeError = (error) => error instanceof Error ? error.message : String(error);

package/dist/editor-lease.d.ts

@@ -3,15 +3,15 @@ import { FolioCliError } from "./errors.js";
 import { Result } from "better-result";
 //#region src/editor-lease.d.ts
 /** How long an editor's lease lasts without renewal. */
-declare const EDITOR_LEASE_MS: number;
+export declare const EDITOR_LEASE_MS: number;
 /** How often an editor renews its lease while it holds it. */
-declare const EDITOR_RENEW_MS: number;
+export declare const EDITOR_RENEW_MS: number;
 /** How long a writer waits for an editor to save and release by default. */
-declare const DEFAULT_FLUSH_WAIT_MS: number;
+export declare const DEFAULT_FLUSH_WAIT_MS: number;
 /** How often a writer retries the lease, and an editor re-checks for requests. */
-declare const FLUSH_POLL_MS = 100;
+export declare const FLUSH_POLL_MS = 100;
 /** A writer's request that the editor holding `leaseToken` save and release. */
-type FlushRequest = {
+export type FlushRequest = {
   id: string;
   /** The token of the lease the writer found; an editor answers only its own. */
   leaseToken: string;
@@ -25,17 +25,17 @@ type FlushRequest = {
   deadline: string;
 };
 /** Request metadata safe to include in a refused editor lease response. */
-type PublicFlushRequest = Omit<FlushRequest, "leaseToken"> & {
+export type PublicFlushRequest = Omit<FlushRequest, "leaseToken"> & {
   leaseToken?: never;
 };
-declare const flushRequestPathFor: (documentPath: string, id: string) => string;
+export declare const flushRequestPathFor: (documentPath: string, id: string) => string;
 /**
  * The flush requests beside `documentPath` whose writer is still waiting.
  * Requests past their deadline (a writer that crashed) are removed.
  */
-declare const pendingFlushRequests: (documentPath: string, now?: Date) => Promise<FlushRequest[]>;
+export declare const pendingFlushRequests: (documentPath: string, now?: Date) => Promise<FlushRequest[]>;
 /** Whether a writer waited for an editor, and what came of it. */
-type FlushOutcome =
+export type FlushOutcome =
 /** The lease was free, stale, or held by a holder that does not flush; no one was asked. */
 {
   type: "notAsked";
@@ -51,7 +51,7 @@ type FlushOutcome =
   type: "timedOut";
   holder: PublicLockHolder;
 };
-type LeaseForWrite = {
+export type LeaseForWrite = {
   lease: AcquiredLease;
   flush: FlushOutcome;
 };
@@ -69,7 +69,7 @@ type AcquireLeaseForWriteOptions = {
  * Take the lease for a write. An editor holding it with unsaved edits is
  * asked to save and release first; see the module comment for the rules.
  */
-declare const acquireLeaseForWrite: ({ documentPath, txId, force, owner, flushWaitMs, pollMs }: AcquireLeaseForWriteOptions) => Promise<Result<LeaseForWrite, FolioCliError>>;
+export declare const acquireLeaseForWrite: ({ documentPath, txId, force, owner, flushWaitMs, pollMs }: AcquireLeaseForWriteOptions) => Promise<Result<LeaseForWrite, FolioCliError>>;
 type AcquireEditorLeaseOptions = {
   documentPath: string;
   /** The editor's lease owner, such as `folio-vscode`. */
@@ -84,8 +84,8 @@ type AcquireEditorLeaseOptions = {
  * renewable, and answering flush requests. Refused (`locked`) while another
  * holder has it or a writer's flush request is pending.
  */
-declare const acquireEditorLease: ({ documentPath, owner, txId, leaseMs, now }: AcquireEditorLeaseOptions) => Promise<Result<AcquiredLease, FolioCliError>>;
-type LeaseKeeper = {
+export declare const acquireEditorLease: ({ documentPath, owner, txId, leaseMs, now }: AcquireEditorLeaseOptions) => Promise<Result<AcquiredLease, FolioCliError>>;
+export type LeaseKeeper = {
   stop: () => void;
 };
 /**
@@ -93,11 +93,11 @@ type LeaseKeeper = {
  * (the lease was taken over or expired), renewing stops and `onLost` runs:
  * the editor must not save under it again.
  */
-declare const keepEditorLeaseAlive: (lease: AcquiredLease, { intervalMs, onLost }: {
+export declare const keepEditorLeaseAlive: (lease: AcquiredLease, { intervalMs, onLost }: {
   intervalMs?: number;
   onLost: (error: FolioCliError) => void;
 }) => LeaseKeeper;
-type FlushWatcher = {
+export type FlushWatcher = {
   close: () => void;
 };
 type WatchFlushRequestsOptions = {
@@ -113,6 +113,6 @@ type WatchFlushRequestsOptions = {
  * watch for promptness plus a poll every `pollMs`, since watch events can
  * be dropped or unsupported (network drives).
  */
-declare const watchFlushRequests: ({ documentPath, token, onRequest, pollMs }: WatchFlushRequestsOptions) => FlushWatcher;
+export declare const watchFlushRequests: ({ documentPath, token, onRequest, pollMs }: WatchFlushRequestsOptions) => FlushWatcher;
 //#endregion
-export { DEFAULT_FLUSH_WAIT_MS, EDITOR_LEASE_MS, EDITOR_RENEW_MS, FLUSH_POLL_MS, FlushOutcome, FlushRequest, FlushWatcher, LeaseForWrite, LeaseKeeper, PublicFlushRequest, acquireEditorLease, acquireLeaseForWrite, flushRequestPathFor, keepEditorLeaseAlive, pendingFlushRequests, watchFlushRequests };
+export {};

package/dist/editor-lease.js

@@ -56,11 +56,11 @@ import { setTimeout } from "node:timers/promises";
 *    a save names the version it was based on and refuses a stale one.
 */
 /** How long an editor's lease lasts without renewal. */
-const EDITOR_LEASE_MS = 30 * 1e3;
+const EDITOR_LEASE_MS = 3e4;
 /** How often an editor renews its lease while it holds it. */
-const EDITOR_RENEW_MS = 10 * 1e3;
+const EDITOR_RENEW_MS = 1e4;
 /** How long a writer waits for an editor to save and release by default. */
-const DEFAULT_FLUSH_WAIT_MS = 5 * 1e3;
+const DEFAULT_FLUSH_WAIT_MS = 5e3;
 /** How often a writer retries the lease, and an editor re-checks for requests. */
 const FLUSH_POLL_MS = 100;
 const publicFlushRequest = ({ id, owner, pid, host, txId, requestedAt, deadline }) => ({

package/dist/errors.d.ts

@@ -6,7 +6,7 @@ import { PublicFlushRequest } from "./editor-lease.js";
  * a script driving both branches on one set of codes; folio uses the subset a
  * local file tool can produce.
  */
-declare const EXIT_CODES: {
+export declare const EXIT_CODES: {
   readonly ok: 0;
   readonly unexpected: 1;
   readonly validation: 2;
@@ -14,14 +14,14 @@ declare const EXIT_CODES: {
   readonly permissionDenied: 8;
   readonly conflict: 10;
 };
-type ExitCode = (typeof EXIT_CODES)[keyof typeof EXIT_CODES];
+export type ExitCode = (typeof EXIT_CODES)[keyof typeof EXIT_CODES];
 /** Every exit code with its meaning, ordered numerically, for `--help`. */
-declare const exitCodeEntries: () => readonly {
+export declare const exitCodeEntries: () => readonly {
   code: number;
   meaning: string;
 }[];
 /** Machine codes carried in `error.code` of a failure envelope. */
-declare const FOLIO_CLI_ERROR_CODES: {
+export declare const FOLIO_CLI_ERROR_CODES: {
   readonly usage: "usage_error";
   readonly invalidInput: "invalid_input";
   readonly invalidDocument: "invalid_document";
@@ -43,10 +43,10 @@ declare const FOLIO_CLI_ERROR_CODES: {
   readonly rendererUnavailable: "renderer_unavailable";
   readonly internal: "internal_error";
 };
-type FolioCliErrorCode = (typeof FOLIO_CLI_ERROR_CODES)[keyof typeof FOLIO_CLI_ERROR_CODES];
-declare const exitCodeForError: (code: FolioCliErrorCode) => ExitCode;
+export type FolioCliErrorCode = (typeof FOLIO_CLI_ERROR_CODES)[keyof typeof FOLIO_CLI_ERROR_CODES];
+export declare const exitCodeForError: (code: FolioCliErrorCode) => ExitCode;
 /** Public error context. Lease-bearing fields cannot accept internal records. */
-type PublicErrorDetails = {
+export type PublicErrorDetails = {
   readonly [key: string]: unknown;
   readonly holder?: PublicLockHolder;
   readonly pending?: readonly PublicFlushRequest[];
@@ -59,7 +59,7 @@ declare const FolioCliError_base: import("better-result").TaggedErrorClass<"Foli
  * step (re-read, pass a flag); `details` carries structured context such as
  * the skipped operations of a refused batch.
  */
-declare class FolioCliError extends FolioCliError_base<{
+export declare class FolioCliError extends FolioCliError_base<{
   code: FolioCliErrorCode;
   message: string;
   hint?: string;
@@ -72,6 +72,6 @@ type CliErrorOptions = {
   details?: PublicErrorDetails;
 };
 /** Build a {@link FolioCliError} without spelling absent optional fields. */
-declare const cliError: ({ code, message, hint, details }: CliErrorOptions) => FolioCliError;
+export declare const cliError: ({ code, message, hint, details }: CliErrorOptions) => FolioCliError;
 //#endregion
-export { EXIT_CODES, ExitCode, FOLIO_CLI_ERROR_CODES, FolioCliError, FolioCliErrorCode, PublicErrorDetails, cliError, exitCodeEntries, exitCodeForError };
+export {};

package/dist/execute-read.d.ts

@@ -4,14 +4,14 @@ import { FolioBlockIdSource, OpenedDocument } from "./document.js";
 import { Result } from "better-result";
 //#region src/execute-read.d.ts
 /** One call against one file: the envelope plus the tool's own arguments. */
-type FileToolCall = {
+export type FileToolCall = {
   path: string;
   /** When present, the call is refused unless the file still has this version. */
   fileVersion?: string | undefined;
   args: Readonly<Record<string, unknown>>;
 };
 /** Per-surface limits on what one read returns. */
-type FolioReadBounds = {
+export type FolioReadBounds = {
   /** Page size when `read_document` passes none; `null` returns every block. */
   defaultMaxBlocks: number | null;
   /** Most `find_text` matches returned; the rest are counted, not listed. */
@@ -19,29 +19,29 @@ type FolioReadBounds = {
   /** Largest serialized result; `null` for no limit. */
   maxResponseBytes: number | null;
 };
-declare const CLI_READ_BOUNDS: FolioReadBounds;
+export declare const CLI_READ_BOUNDS: FolioReadBounds;
 /** The data every file read returns: which file, at which version, and the result. */
-type FileReadData = {
+export type FileReadData = {
   path: string;
   fileVersion: string;
   result: unknown;
 };
 type BlockIdSources = ReadonlyMap<string, FolioBlockIdSource>;
-declare const blockIdSources: ({ reviewer, mintedIds }: OpenedDocument) => BlockIdSources;
+export declare const blockIdSources: ({ reviewer, mintedIds }: OpenedDocument) => BlockIdSources;
 /** Where a block inside a table sits: zero-based table, row, and cell indexes. */
-type FolioTableCell = {
+export type FolioTableCell = {
   table: number;
   row: number;
   cell: number;
 };
 type TableCells = ReadonlyMap<string, FolioTableCell>;
 /** The table cell of every block that sits in one. */
-declare const tableCells: ({ reviewer }: OpenedDocument) => TableCells;
+export declare const tableCells: ({ reviewer }: OpenedDocument) => TableCells;
 type ReadCursor = {
   fileVersion: string;
   afterBlockId: string;
 };
-declare const encodeReadCursor: ({ fileVersion, afterBlockId }: ReadCursor) => string;
+export declare const encodeReadCursor: ({ fileVersion, afterBlockId }: ReadCursor) => string;
 type ReadDocumentPage = {
   blocks: unknown[];
   totalBlocks: number;
@@ -63,8 +63,8 @@ type PageReadDocumentOptions = {
  * the last block of the previous page and the version it was read at, so a
  * page from one version never continues on another.
  */
-declare const pageReadDocument: ({ blocks, sources, cells, fileVersion, args, bounds, pageByteBudget }: PageReadDocumentOptions) => Result<ReadDocumentPage, FolioCliError>;
+export declare const pageReadDocument: ({ blocks, sources, cells, fileVersion, args, bounds, pageByteBudget }: PageReadDocumentOptions) => Result<ReadDocumentPage, FolioCliError>;
 /** Run one read tool, or a compare without a destination. Never writes. */
-declare const executeReadTool: (tool: FolioFileToolSpec, call: FileToolCall, bounds: FolioReadBounds) => Promise<Result<FileReadData, FolioCliError>>;
+export declare const executeReadTool: (tool: FolioFileToolSpec, call: FileToolCall, bounds: FolioReadBounds) => Promise<Result<FileReadData, FolioCliError>>;
 //#endregion
-export { CLI_READ_BOUNDS, FileReadData, FileToolCall, type FolioBlockIdSource, FolioReadBounds, FolioTableCell, blockIdSources, encodeReadCursor, executeReadTool, pageReadDocument, tableCells };
+export type { FolioBlockIdSource };

package/dist/execute-write.d.ts

@@ -8,7 +8,7 @@ import { Result } from "better-result";
 import { FolioAIEditApplyMode } from "@stll/folio-core/server";
 //#region src/execute-write.d.ts
 /** Everything about a write that is not the tool's own arguments. */
-type WriteOptions = {
+export type WriteOptions = {
   destination: WriteDestination;
   /** Already resolved: a write never proceeds without one. */
   author: string;
@@ -33,17 +33,17 @@ type WriteOptions = {
   flushWaitMs?: number;
 };
 /** How a transaction's bytes were produced. */
-type SaveStrategy = "selective" | "full-repack" | "redline";
-declare const TX_ID_PATTERN: RegExp;
+export type SaveStrategy = "selective" | "full-repack" | "redline";
+export declare const TX_ID_PATTERN: RegExp;
 /** JSON with object keys sorted at every depth, for a stable request hash. */
-declare const canonicalJson: (value: unknown) => string;
+export declare const canonicalJson: (value: unknown) => string;
 type ResolvedTarget = {
   sourcePath: string;
   sourceIdentity: FileIdentity;
   destinationPath: string;
 };
 /** The `tool` an editor's whole-package save journals (`save.ts`). */
-declare const EDITOR_SAVE_TOOL = "editor_save";
+export declare const EDITOR_SAVE_TOOL = "editor_save";
 type ResolveTargetOptions = {
   sourcePath: string;
   destination: WriteDestination;
@@ -57,8 +57,8 @@ type ResolveTargetOptions = {
  * that is the input under another name (a symlink, a hard link, a
  * case-insensitive alias): files are compared by device and inode.
  */
-declare const resolveTarget: ({ sourcePath, destination, redline }: ResolveTargetOptions) => Promise<Result<ResolvedTarget, FolioCliError>>;
+export declare const resolveTarget: ({ sourcePath, destination, redline }: ResolveTargetOptions) => Promise<Result<ResolvedTarget, FolioCliError>>;
 /** Run one write tool as a transaction and return its receipt. */
-declare const executeWriteTool: (tool: FolioFileToolSpec, call: FileToolCall, options: WriteOptions) => Promise<Result<Readonly<Record<string, unknown>>, FolioCliError>>;
+export declare const executeWriteTool: (tool: FolioFileToolSpec, call: FileToolCall, options: WriteOptions) => Promise<Result<Readonly<Record<string, unknown>>, FolioCliError>>;
 //#endregion
-export { EDITOR_SAVE_TOOL, SaveStrategy, TX_ID_PATTERN, type WriteDestination, WriteOptions, canonicalJson, executeWriteTool, resolveTarget };
+export type { WriteDestination };

package/dist/file-system.d.ts

@@ -5,19 +5,18 @@
  * editor host bundles) does not pull in the parser.
  */
 /** A file's version: the lowercase hex SHA-256 of its bytes. */
-declare const fileVersionOf: (bytes: Uint8Array) => string;
+export declare const fileVersionOf: (bytes: Uint8Array) => string;
 /** Which file a path named when it was read: device and inode. */
-type FileIdentity = {
+export type FileIdentity = {
   dev: number;
   ino: number;
 };
-declare const sameFile: (left: FileIdentity, right: FileIdentity) => boolean;
+export declare const sameFile: (left: FileIdentity, right: FileIdentity) => boolean;
 /**
  * `O_NOFOLLOW` where the platform has it: opening a path whose last
  * component is a symlink fails instead of following it.
  */
-declare const NO_FOLLOW: number;
+export declare const NO_FOLLOW: number;
 /** The `code` of a Node.js file-system error, when there is one. */
-declare const errnoCode: (error: unknown) => string | undefined;
-//#endregion
-export { FileIdentity, NO_FOLLOW, errnoCode, fileVersionOf, sameFile };
+export declare const errnoCode: (error: unknown) => string | undefined;
+//#endregion

package/dist/flags.d.ts

@@ -3,9 +3,9 @@ import { JsonObjectSchema } from "./registry.js";
 import { Result } from "better-result";
 //#region src/flags.d.ts
 /** Largest `--input` document accepted. */
-declare const MAX_INPUT_BYTES: number;
-type FlagValueType = "boolean" | "integer" | "number" | "string" | "strings" | "json";
-type GeneratedFlag = {
+export declare const MAX_INPUT_BYTES: number;
+export type FlagValueType = "boolean" | "integer" | "number" | "string" | "strings" | "json";
+export type GeneratedFlag = {
   /** The schema property the flag sets. */
   property: string;
   /** `--flag` spelling, without the dashes. */
@@ -13,18 +13,18 @@ type GeneratedFlag = {
   valueType: FlagValueType;
   description: string;
 };
-declare const kebabCase: (name: string) => string;
+export declare const kebabCase: (name: string) => string;
 /**
  * One flag per top-level schema property, in declaration order. `flagNames`
  * renames a property's flag (`{ ids: "id" }` for `--id`).
  */
-declare const flagsForSchema: (schema: JsonObjectSchema, flagNames?: Readonly<Record<string, string>>) => GeneratedFlag[];
+export declare const flagsForSchema: (schema: JsonObjectSchema, flagNames?: Readonly<Record<string, string>>) => GeneratedFlag[];
 type CoerceFlagOptions = {
   flag: GeneratedFlag;
   raw: string | boolean | readonly string[];
 };
 /** Convert one parsed flag value to the type its schema property declares. */
-declare const coerceFlag: ({ flag, raw }: CoerceFlagOptions) => Result<unknown, FolioCliError>;
+export declare const coerceFlag: ({ flag, raw }: CoerceFlagOptions) => Result<unknown, FolioCliError>;
 type ReadInputOptions = {
   source: string;
   readStdin: () => Promise<string>;
@@ -33,6 +33,6 @@ type ReadInputOptions = {
  * Read `--input`: `@path` reads a file, `-` reads stdin, anything else is
  * inline JSON. The result must be a JSON object or array.
  */
-declare const readInputSource: ({ source, readStdin }: ReadInputOptions) => Promise<Result<Record<string, unknown> | unknown[], FolioCliError>>;
+export declare const readInputSource: ({ source, readStdin }: ReadInputOptions) => Promise<Result<Record<string, unknown> | unknown[], FolioCliError>>;
 //#endregion
-export { FlagValueType, GeneratedFlag, MAX_INPUT_BYTES, coerceFlag, flagsForSchema, kebabCase, readInputSource };
+export {};

package/dist/flags.js

@@ -12,7 +12,7 @@ import { readFile } from "node:fs/promises";
 * flags given alongside it override its fields.
 */
 /** Largest `--input` document accepted. */
-const MAX_INPUT_BYTES = 16 * 1024 * 1024;
+const MAX_INPUT_BYTES = 16777216;
 const kebabCase = (name) => name.replace(/[A-Z]/gu, (letter) => `-${letter.toLowerCase()}`);
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const valueTypeOf = (schema) => {

package/dist/journal.d.ts

@@ -1,7 +1,7 @@
 import { FolioCliError } from "./errors.js";
 import { Result } from "better-result";
 //#region src/journal.d.ts
-type JournalCommit = {
+export type JournalCommit = {
   type: "commit";
   txId: string;
   /** Hash of the request, so a retry with the same txId but other arguments is refused. */
@@ -24,9 +24,9 @@ type JournalCommit = {
   /** What the command returned, replayed verbatim for a retry with the same txId. */
   receipt: Readonly<Record<string, unknown>>;
 };
-declare const RECOVERY_DISCARD_REASONS: readonly ["notJournaled", "otherDocument", "notRegularFile", "stageChanged", "invalidPackage", "destinationMoved", "leaseLost", "renameRefused"];
-type RecoveryDiscardReason = (typeof RECOVERY_DISCARD_REASONS)[number];
-type JournalRecovery = {
+export declare const RECOVERY_DISCARD_REASONS: readonly ["notJournaled", "otherDocument", "notRegularFile", "stageChanged", "invalidPackage", "destinationMoved", "leaseLost", "renameRefused"];
+export type RecoveryDiscardReason = (typeof RECOVERY_DISCARD_REASONS)[number];
+export type JournalRecovery = {
   type: "recovery";
   txId: string;
   path: string;
@@ -37,9 +37,9 @@ type JournalRecovery = {
   action: "discarded";
   reason: RecoveryDiscardReason;
 });
-type JournalEntry = JournalCommit | JournalRecovery;
+export type JournalEntry = JournalCommit | JournalRecovery;
 /** The fields of a commit line recovery and replay read back. */
-type CommittedTransaction = {
+export type CommittedTransaction = {
   txId: string;
   path: string;
   requestHash: string;
@@ -47,17 +47,17 @@ type CommittedTransaction = {
   destinationVersionBefore: string | null;
   receipt: Readonly<Record<string, unknown>>;
 };
-declare const journalPathFor: (documentPath: string, override: string | undefined) => string;
+export declare const journalPathFor: (documentPath: string, override: string | undefined) => string;
 /** Append one line and sync it to disk before returning. */
-declare const appendJournal: (journalPath: string, entry: JournalEntry) => Promise<Result<void, FolioCliError>>;
+export declare const appendJournal: (journalPath: string, entry: JournalEntry) => Promise<Result<void, FolioCliError>>;
 /**
  * The committed transaction with `txId`, if the journal has one and recovery
  * did not discard it. Torn or foreign lines (a crash mid-append) are skipped.
  * A journal (or `.folio`) that is a symlink or hard link is refused.
  */
-declare const findCommit: (journalPath: string, txId: string) => Promise<Result<CommittedTransaction | undefined, FolioCliError>>;
+export declare const findCommit: (journalPath: string, txId: string) => Promise<Result<CommittedTransaction | undefined, FolioCliError>>;
 /** The newest commit the journal records for one document. */
-type LatestCommit = {
+export type LatestCommit = {
   txId: string;
   tool: string;
   author: string;
@@ -71,10 +71,10 @@ type LatestCommit = {
  * `null`. Reads only through a plain `.folio` directory and never creates
  * one, so a read-only preview can call it.
  */
-declare const latestCommitFor: (documentPath: string, journalPath?: string) => Promise<LatestCommit | null>;
-declare const stagePrefixFor: (documentPath: string) => string;
-declare const stagePathFor: (documentPath: string, txId: string) => string;
-type RecoveryAction = {
+export declare const latestCommitFor: (documentPath: string, journalPath?: string) => Promise<LatestCommit | null>;
+export declare const stagePrefixFor: (documentPath: string) => string;
+export declare const stagePathFor: (documentPath: string, txId: string) => string;
+export type RecoveryAction = {
   txId: string;
   action: "rolledForward";
 } | {
@@ -93,6 +93,6 @@ type RecoverStagesOptions = {
  * Removing a discarded stage unlinks the name only; a symlink's target is
  * never touched.
  */
-declare const recoverStages: ({ documentPath, journalPath, now }: RecoverStagesOptions) => Promise<Result<RecoveryAction[], FolioCliError>>;
+export declare const recoverStages: ({ documentPath, journalPath, now }: RecoverStagesOptions) => Promise<Result<RecoveryAction[], FolioCliError>>;
 //#endregion
-export { CommittedTransaction, JournalCommit, JournalEntry, JournalRecovery, LatestCommit, RECOVERY_DISCARD_REASONS, RecoveryAction, RecoveryDiscardReason, appendJournal, findCommit, journalPathFor, latestCommitFor, recoverStages, stagePathFor, stagePrefixFor };
+export {};

package/dist/lock.d.ts

@@ -2,12 +2,12 @@ import { FolioCliError } from "./errors.js";
 import { Result } from "better-result";
 //#region src/lock.d.ts
 /** How long a command-line transaction's lease lasts without renewal. */
-declare const TRANSACTION_LEASE_MS: number;
+export declare const TRANSACTION_LEASE_MS: number;
 /** The owner a lease records when the caller names none. */
-declare const DEFAULT_LEASE_OWNER = "folio-cli";
+export declare const DEFAULT_LEASE_OWNER = "folio-cli";
 /** A lease owner is 1 to 64 letters, digits, '.', '_' or '-'. */
-declare const isLeaseOwner: (value: string) => boolean;
-type LockHolder = {
+export declare const isLeaseOwner: (value: string) => boolean;
+export type LockHolder = {
   owner: string;
   pid: number;
   host: string;
@@ -20,13 +20,13 @@ type LockHolder = {
   acceptsFlush?: true;
 };
 /** Holder metadata safe to return to a caller that does not own the lease. */
-type PublicLockHolder = Omit<LockHolder, "token"> & {
+export type PublicLockHolder = Omit<LockHolder, "token"> & {
   token?: never;
 };
-declare const publicLockHolder: ({ owner, pid, host, txId, acquiredAt, expiresAt, acceptsFlush }: LockHolder) => PublicLockHolder;
-declare const lockPathFor: (documentPath: string) => string;
+export declare const publicLockHolder: ({ owner, pid, host, txId, acquiredAt, expiresAt, acceptsFlush }: LockHolder) => PublicLockHolder;
+export declare const lockPathFor: (documentPath: string) => string;
 /** What is beside the document: no lock, or a lock with its parsed holder when it has one. */
-type LeaseState = {
+export type LeaseState = {
   type: "free";
 } | {
   type: "held";
@@ -41,10 +41,10 @@ type LeaseState = {
  * held until it is older than a whole lease, so a lock another process is
  * writing is never taken for abandoned.
  */
-declare const isStaleLease: (state: LeaseState, now: Date) => boolean;
+export declare const isStaleLease: (state: LeaseState, now: Date) => boolean;
 /** The lease currently beside `documentPath`. A symlinked lock reads as unreadable. */
-declare const readLease: (documentPath: string) => Promise<LeaseState>;
-type AcquiredLease = {
+export declare const readLease: (documentPath: string) => Promise<LeaseState>;
+export type AcquiredLease = {
   /** The lock's contents as last written by this handle. */
   holder: LockHolder;
   /** Refuse unless the lock still carries this lease's token. */
@@ -67,17 +67,17 @@ type AcquireLeaseOptions = {
   now?: Date;
 };
 /** `.<name>.folio-lock.swap`: held for the instant one process changes an existing lock. */
-declare const lockSwapPathFor: (documentPath: string) => string;
+export declare const lockSwapPathFor: (documentPath: string) => string;
 /**
  * Act under a lease another call acquired, named by its token: `folio save
  * --lease-token` from the editor that holds it. Releasing stays with that
  * holder, so this handle's `release` does nothing.
  */
-declare const adoptLease: (documentPath: string, token: string) => Promise<Result<AcquiredLease, FolioCliError>>;
+export declare const adoptLease: (documentPath: string, token: string) => Promise<Result<AcquiredLease, FolioCliError>>;
 /**
  * Take the lease for one transaction. A stale lease is replaced; a live or
  * unreadable one refuses with `locked` unless `force`.
  */
-declare const acquireLease: ({ documentPath, txId, force, owner, leaseMs, acceptsFlush, now }: AcquireLeaseOptions) => Promise<Result<AcquiredLease, FolioCliError>>;
+export declare const acquireLease: ({ documentPath, txId, force, owner, leaseMs, acceptsFlush, now }: AcquireLeaseOptions) => Promise<Result<AcquiredLease, FolioCliError>>;
 //#endregion
-export { AcquiredLease, DEFAULT_LEASE_OWNER, LeaseState, LockHolder, PublicLockHolder, TRANSACTION_LEASE_MS, acquireLease, adoptLease, isLeaseOwner, isStaleLease, lockPathFor, lockSwapPathFor, publicLockHolder, readLease };
+export {};

package/dist/lock.js

@@ -27,7 +27,7 @@ import { setTimeout } from "node:timers/promises";
 * than a lease. Reads never consult it.
 */
 /** How long a command-line transaction's lease lasts without renewal. */
-const TRANSACTION_LEASE_MS = 300 * 1e3;
+const TRANSACTION_LEASE_MS = 3e5;
 /** The owner a lease records when the caller names none. */
 const DEFAULT_LEASE_OWNER = "folio-cli";
 const OWNER_PATTERN = /^[\w.-]{1,64}$/u;
@@ -135,9 +135,9 @@ const placeLock = async (lockPath, contents, mode) => {
 };
 const encodeHolder = (holder) => encodeUtf8(`${JSON.stringify(holder)}\n`);
 /** How long a swap lock may stand before another process breaks it (its holder crashed). */
-const SWAP_STALE_MS = 10 * 1e3;
+const SWAP_STALE_MS = 1e4;
 /** How long to wait for another process's swap before refusing. */
-const SWAP_WAIT_MS = 5 * 1e3;
+const SWAP_WAIT_MS = 5e3;
 const SWAP_POLL_MS = 5;
 /** `.<name>.folio-lock.swap`: held for the instant one process changes an existing lock. */
 const lockSwapPathFor = (documentPath) => `${lockPathFor(documentPath)}.swap`;