toolcraft-openapi 0.0.17 → 0.0.19

package/dist/bin/generate.js

@@ -57,6 +57,13 @@ export async function runGenerateCli(argv = process.argv, services = {
             services.stderr.write(`${error.message}\n`);
             return 1;
         }
+        if (error instanceof Error && error.name === "ToolcraftBugError") {
+            services.stderr.write(`toolcraft hit an internal invariant: ${error.message}\n` +
+                `This is a bug in toolcraft or in the command definition; ` +
+                `it cannot be worked around by changing argv. ` +
+                `File an issue.\n`);
+            return 1;
+        }
         throw error;
     }
 }

package/dist/define-client.js

@@ -1,4 +1,4 @@
-import { defineCommand, defineGroup, UserError } from "toolcraft";
+import { ToolcraftBugError, defineCommand, defineGroup, UserError } from "toolcraft";
 import { toMcpPrefix } from "./naming.js";
 const CLI_SCOPE = ["cli"];
 export function defineClient(options) {
@@ -61,7 +61,7 @@ function registerSource(node, source, nodeSources) {
 function getRegisteredSource(nodeSources, node) {
     const source = nodeSources.get(node);
     if (source === undefined) {
-        throw new Error("Bug: merged command node is missing source metadata.");
+        throw new ToolcraftBugError("merged command node is missing source metadata.");
     }
     return source;
 }

package/dist/generate.js

@@ -1,4 +1,4 @@
-import { UserError } from "toolcraft";
+import { ToolcraftBugError, UserError } from "toolcraft";
 import { METHOD_DEFAULTS, deriveNoun, deriveVerb, isIdentifierName, normalizeParamName, toCamelCase, toPascalCase } from "./naming.js";
 import { groupByNoun } from "./group-by-noun.js";
 import { renderPreflightBlock, renderRequestShape } from "./interpreter.js";
@@ -557,7 +557,7 @@ const FIELD_ASSEMBLERS = {
 };
 function expectQueryArraySerialization(querySerialization) {
     if (querySerialization === undefined) {
-        throw new Error("Missing query array serialization for generated query array field.");
+        throw new ToolcraftBugError("Missing query array serialization for generated query array field.");
     }
     return querySerialization;
 }

package/dist/http.d.ts

@@ -17,10 +17,29 @@ export interface HttpRequestOptions {
     writeStdout?: (chunk: string) => void;
     writeStderr?: (chunk: string) => void;
 }
+export interface HttpErrorRequest {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    body?: unknown;
+}
+export interface HttpErrorResponse {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: unknown;
+}
 export declare class HttpError extends Error {
     readonly status: number;
-    readonly body: unknown;
-    constructor(status: number, body: unknown, message?: string);
+    readonly statusText: string;
+    readonly request: HttpErrorRequest;
+    readonly response: HttpErrorResponse;
+    get body(): unknown;
+    constructor(args: {
+        request: HttpErrorRequest;
+        response: HttpErrorResponse;
+        message?: string;
+    });
 }
 export declare function requestJson<TResult = unknown>(options: HttpRequestOptions): Promise<TResult | undefined>;
 export {};

package/dist/http.js

@@ -1,13 +1,23 @@
 import { text as designText } from "@poe-code/design-system";
 import { UserError } from "toolcraft";
+import { classifyNetworkError } from "./network-error.js";
+const TRANSCRIPT_BODY_BYTE_LIMIT = 4 * 1024;
 export class HttpError extends Error {
     status;
-    body;
-    constructor(status, body, message = `HTTP ${status}`) {
-        super(message);
+    statusText;
+    request;
+    response;
+    get body() {
+        return this.response.body;
+    }
+    constructor(args) {
+        super(args.message ??
+            `${args.request.method} ${args.request.url} → ${args.response.status} ${args.response.statusText}`);
         this.name = "HttpError";
-        this.status = status;
-        this.body = body;
+        this.status = args.response.status;
+        this.statusText = args.response.statusText;
+        this.request = args.request;
+        this.response = args.response;
     }
 }
 export async function requestJson(options) {
@@ -20,34 +30,73 @@ export async function requestJson(options) {
     const writeStdout = options.writeStdout ?? process.stdout.write.bind(process.stdout);
     const writeStderr = options.writeStderr ?? process.stderr.write.bind(process.stderr);
     const requestLine = `${method} ${url}`;
-    if (options.verbose) {
-        writeStderr(`${designText.muted(requestLine)}\n`);
-    }
     if (options.dryRun) {
         writeStdout(formatDryRunOutput(requestLine, headers, options.body));
         return undefined;
     }
-    const response = await (options.fetch ?? globalThis.fetch)(url, {
-        method,
-        headers,
-        body: serializedBody,
-        signal: options.signal,
-    });
+    if (options.verbose) {
+        writeStderr(formatTranscriptLines(formatVerboseRequestTranscript(method, url, headers, options.body)));
+    }
+    let response;
+    try {
+        response = await (options.fetch ?? globalThis.fetch)(url, {
+            method,
+            headers,
+            body: serializedBody,
+            signal: options.signal
+        });
+    }
+    catch (error) {
+        throw classifyNetworkError(error, url) ?? error;
+    }
     const text = await response.text();
     const contentType = response.headers.get("content-type");
+    const request = createHttpErrorRequest(method, url, headers, options.body);
+    const responseHeaders = serializeHeaders(response.headers);
     if (response.ok) {
         if (text.length === 0) {
+            if (options.verbose) {
+                writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders)));
+            }
             return undefined;
         }
         if (!isJsonContentType(contentType)) {
-            throw new HttpError(response.status, text, `Expected a JSON response body but received content-type ${JSON.stringify(contentType ?? "<missing>")}.`);
+            if (options.verbose) {
+                writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, text)));
+            }
+            throw new HttpError({
+                request,
+                response: {
+                    status: response.status,
+                    statusText: response.statusText,
+                    headers: responseHeaders,
+                    body: text
+                },
+                message: `Expected a JSON response body but received content-type ${JSON.stringify(contentType ?? "<missing>")}.`
+            });
         }
-        return JSON.parse(text);
+        const body = JSON.parse(text);
+        if (options.verbose) {
+            writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, body)));
+        }
+        return body;
     }
     if (response.status === 401) {
         await options.tokenSource.invalidate?.();
     }
-    throw new HttpError(response.status, parseResponseBody(text, contentType));
+    const body = parseResponseBody(text, contentType);
+    if (options.verbose) {
+        writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, body)));
+    }
+    throw new HttpError({
+        request,
+        response: {
+            status: response.status,
+            statusText: response.statusText,
+            headers: responseHeaders,
+            body
+        }
+    });
 }
 function buildRequestUrl(options) {
     const resolvedPath = substitutePathParams(options.path, options.pathParams);
@@ -87,25 +136,101 @@ function appendQueryValue(searchParams, key, value) {
 function createHeaders(token, hasBody) {
     return {
         ...(token === undefined ? {} : { Authorization: `Bearer ${token}` }),
-        ...(hasBody ? { "Content-Type": "application/json" } : {}),
+        ...(hasBody ? { "Content-Type": "application/json" } : {})
+    };
+}
+function createHttpErrorRequest(method, url, headers, body) {
+    return {
+        method,
+        url,
+        headers: redactHeaders(headers),
+        ...(body === undefined ? {} : { body })
     };
 }
+function serializeHeaders(headers) {
+    return Object.fromEntries(headers.entries());
+}
+function redactHeaders(headers) {
+    return Object.fromEntries(Object.entries(headers).map(([key, value]) => [key, redactHeaderValue(key, value)]));
+}
+function redactHeaderValue(key, value) {
+    if (key.toLowerCase() === "authorization" && value.startsWith("Bearer ")) {
+        return "Bearer ****";
+    }
+    return value;
+}
 function formatDryRunOutput(requestLine, headers, body) {
     const lines = [
         requestLine,
         ...Object.entries(headers).map(([key, value]) => {
-            const headerValue = key.toLowerCase() === "authorization" && value.startsWith("Bearer ")
-                ? "Bearer ****"
-                : value;
+            const headerValue = redactHeaderValue(key, value);
             return `${key}: ${headerValue}`;
         }),
-        "",
+        ""
     ];
     if (body !== undefined) {
         lines.push(JSON.stringify(body));
     }
     return `${lines.join("\n")}\n`;
 }
+function formatVerboseRequestTranscript(method, url, headers, body) {
+    const lines = [
+        `→ ${method} ${url}`,
+        ...Object.entries(headers).map(([key, value]) => {
+            const headerValue = redactHeaderValue(key, value);
+            return `    ${key}: ${headerValue}`;
+        })
+    ];
+    if (body !== undefined) {
+        lines.push(...indentTranscriptBlock(formatTranscriptBody(body)));
+    }
+    return lines;
+}
+function formatVerboseResponseTranscript(response, headers, body) {
+    const lines = [
+        `← ${response.status} ${response.statusText}`,
+        ...Object.entries(headers).map(([key, value]) => `    ${key}: ${value}`)
+    ];
+    if (body !== undefined) {
+        lines.push(...indentTranscriptBlock(formatTranscriptBody(body)));
+    }
+    return lines;
+}
+function formatTranscriptLines(lines) {
+    return `${lines.map((line) => formatTranscriptLine(line)).join("\n")}\n`;
+}
+function formatTranscriptLine(line) {
+    if (!process.stderr.isTTY) {
+        return line;
+    }
+    return designText.muted(line);
+}
+function formatTranscriptBody(body) {
+    const formatted = typeof body === "string" ? body : JSON.stringify(body, null, 2);
+    return truncateTranscriptBody(formatted ?? String(body));
+}
+function indentTranscriptBlock(value) {
+    return value.split("\n").map((line) => `    ${line}`);
+}
+function truncateTranscriptBody(value) {
+    const encoder = new TextEncoder();
+    const encoded = encoder.encode(value);
+    if (encoded.byteLength <= TRANSCRIPT_BODY_BYTE_LIMIT) {
+        return value;
+    }
+    const truncatedChars = [];
+    let truncatedByteLength = 0;
+    for (const character of value) {
+        const characterByteLength = encoder.encode(character).byteLength;
+        if (truncatedByteLength + characterByteLength > TRANSCRIPT_BODY_BYTE_LIMIT) {
+            break;
+        }
+        truncatedChars.push(character);
+        truncatedByteLength += characterByteLength;
+    }
+    const truncatedBytes = encoded.byteLength - truncatedByteLength;
+    return `${truncatedChars.join("")}\n… (${truncatedBytes} bytes truncated)`;
+}
 function parseResponseBody(text, contentType) {
     if (text.length === 0) {
         return undefined;

package/dist/index.d.ts

@@ -9,4 +9,4 @@ export type { AuthProvider, CommandContributor, TokenSource } from "./auth/types
 export { bearerTokenAuth } from "./auth/bearer-token-auth.js";
 export type { BearerTokenAuthOptions } from "./auth/bearer-token-auth.js";
 export { HttpError, requestJson } from "./http.js";
-export type { HttpRequestOptions, QueryValue } from "./http.js";
+export type { HttpErrorRequest, HttpErrorResponse, HttpRequestOptions, QueryValue } from "./http.js";

package/dist/lock.d.ts

@@ -8,7 +8,7 @@ export interface LockFileSystem {
     readFile(filePath: string, encoding: BufferEncoding): Promise<string>;
     writeFile(filePath: string, contents: string, encoding: BufferEncoding): Promise<void>;
 }
-export declare function parseOpenApiLock(contents: string): OpenApiLock | null;
+export declare function parseOpenApiLock(contents: string, lockPath: string): OpenApiLock | null;
 export declare function stringifyOpenApiLock(lock: OpenApiLock): string;
 export declare function readOpenApiLock(fs: Pick<LockFileSystem, "readFile">, lockPath: string): Promise<OpenApiLock | null>;
 export declare function writeOpenApiLock(fs: LockFileSystem, lockPath: string, lock: OpenApiLock): Promise<void>;

package/dist/lock.js

@@ -1,11 +1,13 @@
 import path from "node:path";
-export function parseOpenApiLock(contents) {
+import { UserError } from "toolcraft";
+import { renderSourceSnippet } from "toolcraft/source-snippet";
+export function parseOpenApiLock(contents, lockPath) {
     let parsed;
     try {
         parsed = JSON.parse(contents);
     }
-    catch {
-        return null;
+    catch (error) {
+        throw new UserError(formatJsonParseError(lockPath, contents, error), { cause: error });
     }
     if (typeof parsed !== "object" ||
         parsed === null ||
@@ -27,7 +29,7 @@ export function stringifyOpenApiLock(lock) {
 }
 export async function readOpenApiLock(fs, lockPath) {
     try {
-        return parseOpenApiLock(await fs.readFile(lockPath, "utf8"));
+        return parseOpenApiLock(await fs.readFile(lockPath, "utf8"), lockPath);
     }
     catch (error) {
         if (isNotFoundError(error)) {
@@ -38,7 +40,13 @@ export async function readOpenApiLock(fs, lockPath) {
 }
 export async function writeOpenApiLock(fs, lockPath, lock) {
     await fs.mkdir(path.dirname(lockPath), { recursive: true });
-    await fs.writeFile(lockPath, stringifyOpenApiLock(lock), "utf8");
+    try {
+        await fs.writeFile(lockPath, stringifyOpenApiLock(lock), "utf8");
+    }
+    catch (error) {
+        const code = getErrorCode(error);
+        throw new UserError(`Failed to write lock file "${lockPath}"${code === undefined ? "" : ` (${code})`}: ${getErrorMessage(error)}`, { cause: error });
+    }
 }
 function isNotFoundError(error) {
     return (typeof error === "object" &&
@@ -46,3 +54,99 @@ function isNotFoundError(error) {
         "code" in error &&
         error.code === "ENOENT");
 }
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function formatJsonParseError(lockPath, source, error) {
+    const location = getJsonParseErrorLocation(error, source);
+    const message = getErrorMessage(error);
+    if (location === null) {
+        return `Lock file "${lockPath}" is not valid JSON: ${message}.`;
+    }
+    return (`Lock file "${lockPath}" is not valid JSON: ${message} ` +
+        `at line ${location.line} column ${location.column}.\n` +
+        renderSourceSnippet({
+            source,
+            line: location.line,
+            column: location.column,
+            filePath: lockPath
+        }));
+}
+function getJsonParseErrorLocation(error, source) {
+    const causeLocation = getJsonParseCauseLocation(error);
+    if (causeLocation !== null) {
+        return causeLocation;
+    }
+    const directPosition = getNumericProperty(error, "position");
+    if (directPosition !== null) {
+        return getSourceOffsetLocation(source, directPosition);
+    }
+    const messagePosition = getJsonParseMessagePosition(getErrorMessage(error));
+    if (messagePosition !== null) {
+        return getSourceOffsetLocation(source, messagePosition);
+    }
+    return null;
+}
+function getJsonParseCauseLocation(error) {
+    if (typeof error !== "object" || error === null || !("cause" in error)) {
+        return null;
+    }
+    const cause = error.cause;
+    const line = getNumericProperty(cause, "line");
+    const column = getNumericProperty(cause, "column") ?? getNumericProperty(cause, "col");
+    if (line === null || column === null) {
+        return null;
+    }
+    return { line, column };
+}
+function getNumericProperty(value, key) {
+    if (typeof value !== "object" || value === null || !(key in value)) {
+        return null;
+    }
+    const propertyValue = value[key];
+    return typeof propertyValue === "number" && Number.isFinite(propertyValue)
+        ? propertyValue
+        : null;
+}
+function getJsonParseMessagePosition(message) {
+    const marker = " at position ";
+    const markerIndex = message.indexOf(marker);
+    if (markerIndex === -1) {
+        return null;
+    }
+    const startIndex = markerIndex + marker.length;
+    let endIndex = startIndex;
+    while (endIndex < message.length && isAsciiDigit(message[endIndex] ?? "")) {
+        endIndex += 1;
+    }
+    if (endIndex === startIndex) {
+        return null;
+    }
+    return Number.parseInt(message.slice(startIndex, endIndex), 10);
+}
+function getSourceOffsetLocation(source, offset) {
+    let line = 1;
+    let column = 1;
+    const boundedOffset = Math.max(0, Math.floor(offset));
+    for (let index = 0; index < boundedOffset && index < source.length; index += 1) {
+        if (source[index] === "\n") {
+            line += 1;
+            column = 1;
+            continue;
+        }
+        column += 1;
+    }
+    return { line, column };
+}
+function isAsciiDigit(value) {
+    return value >= "0" && value <= "9";
+}
+function getErrorCode(error) {
+    if (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        typeof error.code === "string") {
+        return error.code;
+    }
+    return undefined;
+}

package/dist/mock/fetch.js

@@ -72,7 +72,7 @@ export async function mockFetch(options) {
         }
     };
 }
-class MockFetchError extends Error {
+class MockFetchError extends UserError {
     constructor(message) {
         super(message);
         this.name = "MockFetchError";

package/dist/network-error.d.ts

@@ -0,0 +1,2 @@
+import { UserError } from "toolcraft";
+export declare function classifyNetworkError(error: unknown, url: string): UserError | null;

package/dist/network-error.js

@@ -0,0 +1,83 @@
+import { UserError } from "toolcraft";
+export function classifyNetworkError(error, url) {
+    const networkError = findNetworkError(error);
+    const urlParts = new URL(url);
+    const host = getHost(networkError, urlParts);
+    switch (networkError?.code) {
+        case "ECONNREFUSED":
+            return new UserError(`Connection refused: ${host}:${getPort(networkError, urlParts)}. Is the server running?`, { cause: error });
+        case "ETIMEDOUT":
+            return new UserError(`Request timed out after ${getTimeoutMs(networkError)}ms: ${url}.`, {
+                cause: error
+            });
+        case "ENOTFOUND":
+            return new UserError(`DNS lookup failed for ${host}. Check the URL or your network.`, {
+                cause: error
+            });
+        case "ECONNRESET":
+            return new UserError(`Connection reset by ${host}. Likely transient: try again.`, {
+                cause: error
+            });
+        case "EAI_AGAIN":
+            return new UserError(`Temporary DNS failure for ${host}. Network may be down.`, {
+                cause: error
+            });
+    }
+    if (findAbortError(error) !== null) {
+        return new UserError(`Request aborted: ${url}.`, { cause: error });
+    }
+    if (error instanceof TypeError && error.message === "fetch failed" && !hasCause(error)) {
+        return new UserError(`Network request failed: ${url}.`, { cause: error });
+    }
+    return null;
+}
+function findNetworkError(error) {
+    let current = error;
+    while (isErrorLikeObject(current)) {
+        if (typeof current.code === "string") {
+            return current;
+        }
+        current = current.cause;
+    }
+    return null;
+}
+function isAbortError(error) {
+    return isErrorLikeObject(error) && error.name === "AbortError";
+}
+function findAbortError(error) {
+    let current = error;
+    while (isErrorLikeObject(current)) {
+        if (isAbortError(current)) {
+            return current;
+        }
+        current = current.cause;
+    }
+    return null;
+}
+function hasCause(error) {
+    return "cause" in error && error.cause !== undefined;
+}
+function getHost(error, url) {
+    return typeof error?.address === "string" ? error.address : url.hostname;
+}
+function getPort(error, url) {
+    if (typeof error?.port === "number" || typeof error?.port === "string") {
+        return String(error.port);
+    }
+    if (url.port) {
+        return url.port;
+    }
+    return url.protocol === "https:" ? "443" : "80";
+}
+function getTimeoutMs(error) {
+    if (typeof error.ms === "number" || typeof error.ms === "string") {
+        return String(error.ms);
+    }
+    if (typeof error.timeout === "number" || typeof error.timeout === "string") {
+        return String(error.timeout);
+    }
+    return "unknown";
+}
+function isErrorLikeObject(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/spec-source.js

@@ -2,6 +2,8 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { parse as parseYaml } from "yaml";
 import { UserError } from "toolcraft";
+import { renderSourceSnippet } from "toolcraft/source-snippet";
+import { classifyNetworkError } from "./network-error.js";
 export async function readOpenApiSourceText(input, services) {
     const inputUrl = input instanceof URL ? input : tryParseUrl(input);
     const sourceLabel = formatSourceLabel(input);
@@ -18,9 +20,21 @@ export async function readOpenApiSourceText(input, services) {
         if (inputUrl.protocol !== "http:" && inputUrl.protocol !== "https:") {
             throw new UserError(`Unsupported OpenAPI input URL protocol ${JSON.stringify(inputUrl.protocol)}.`);
         }
-        const response = await services.fetch(inputUrl.toString());
+        let response;
+        try {
+            response = await services.fetch(inputUrl.toString());
+        }
+        catch (error) {
+            throw classifyNetworkError(error, inputUrl.toString()) ?? error;
+        }
         if (!response.ok) {
-            throw new UserError(`Failed to fetch ${JSON.stringify(inputUrl.toString())}: ${response.status} ${response.statusText}`);
+            const contentType = response.headers.get("content-type") ?? "";
+            const text = await response.text().catch(() => "");
+            const snippet = text.length === 0 ? "" : `\n  body: ${truncate(text, 500)}`;
+            throw new UserError(`Failed to fetch ${JSON.stringify(inputUrl.toString())}: ` +
+                `${response.status} ${response.statusText}` +
+                (contentType ? ` (content-type: ${contentType})` : "") +
+                snippet);
         }
         return await response.text();
     }
@@ -37,7 +51,7 @@ export function parseOpenApiDocument(sourceText, input) {
         parsed = parseYaml(sourceText);
     }
     catch (error) {
-        throw new UserError(`Failed to parse OpenAPI document ${JSON.stringify(formatSourceLabel(input))}: ${getErrorMessage(error)}`);
+        throw new UserError(`Failed to parse OpenAPI document ${JSON.stringify(formatSourceLabel(input))}: ${formatParseErrorMessage(error, sourceText, formatSourceLabel(input))}`);
     }
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
         throw new UserError(`OpenAPI document ${JSON.stringify(formatSourceLabel(input))} must parse to an object.`);
@@ -61,3 +75,89 @@ function getErrorMessage(error) {
     }
     return String(error);
 }
+function formatParseErrorMessage(error, sourceText, filePath) {
+    const message = getErrorMessage(error);
+    const linePosition = getYamlLinePosition(error) ?? getYamlOffsetPosition(error, sourceText);
+    if (linePosition === null) {
+        // yaml parse errors do not always expose positional metadata for every failure mode.
+        return message;
+    }
+    const positionText = `at line ${linePosition.line} column ${linePosition.column}`;
+    const messageWithPosition = message.includes(positionText)
+        ? message
+        : `${message} (${positionText})`;
+    return `${messageWithPosition}\n${renderSourceSnippet({
+        source: sourceText,
+        line: linePosition.line,
+        column: linePosition.column,
+        filePath
+    })}`;
+}
+function getYamlLinePosition(error) {
+    if (typeof error !== "object" || error === null || !("linePos" in error)) {
+        return null;
+    }
+    const linePos = error.linePos;
+    if (!Array.isArray(linePos) || linePos.length === 0) {
+        return null;
+    }
+    const firstPosition = linePos[0];
+    if (typeof firstPosition !== "object" || firstPosition === null) {
+        return null;
+    }
+    const line = "line" in firstPosition ? firstPosition.line : undefined;
+    const column = "col" in firstPosition ? firstPosition.col : undefined;
+    if (typeof line !== "number" || typeof column !== "number") {
+        return null;
+    }
+    return { line, column };
+}
+function getYamlOffsetPosition(error, sourceText) {
+    if (typeof error !== "object" || error === null || !("pos" in error)) {
+        return null;
+    }
+    const pos = error.pos;
+    if (!Array.isArray(pos) || typeof pos[0] !== "number" || pos[0] < 0) {
+        return null;
+    }
+    return getSourceTextPosition(sourceText, pos[0]);
+}
+function getSourceTextPosition(sourceText, offset) {
+    let line = 1;
+    let column = 1;
+    for (let index = 0; index < offset && index < sourceText.length; index += 1) {
+        if (sourceText[index] === "\n") {
+            line += 1;
+            column = 1;
+            continue;
+        }
+        column += 1;
+    }
+    return { line, column };
+}
+function truncate(value, maxLength) {
+    const collapsed = collapseToSingleLine(value);
+    if (collapsed.length <= maxLength) {
+        return collapsed;
+    }
+    return `${collapsed.slice(0, maxLength)}…`;
+}
+function collapseToSingleLine(value) {
+    const characters = [];
+    let previousWasWhitespace = false;
+    for (const character of value) {
+        if (isWhitespace(character)) {
+            if (!previousWasWhitespace) {
+                characters.push(" ");
+                previousWasWhitespace = true;
+            }
+            continue;
+        }
+        characters.push(character);
+        previousWasWhitespace = false;
+    }
+    return characters.join("").trim();
+}
+function isWhitespace(character) {
+    return character.trim().length === 0;
+}