toolcraft-openapi 0.0.38 → 0.0.40

package/dist/http.js

@@ -1,26 +1,11 @@
+import path from "node:path";
+import { randomUUID } from "node:crypto";
 import { text as designText } from "toolcraft-design";
-import { UserError } from "toolcraft";
+import { HttpError, UserError, createHttpError } from "toolcraft";
 import { classifyNetworkError } from "./network-error.js";
 import { redactHeaders, redactHeaderValue, redactSensitiveQueryValues } from "./redaction.js";
+export { HttpError };
 const TRANSCRIPT_BODY_BYTE_LIMIT = 4 * 1024;
-export class HttpError extends Error {
-    status;
-    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 = args.response.status;
-        this.statusText = args.response.statusText;
-        this.request = args.request;
-        this.response = args.response;
-    }
-}
 export async function requestJson(options) {
     const token = options.auth === "none" ? undefined : await options.tokenSource.getToken();
     const method = options.method.toUpperCase();
@@ -37,7 +22,12 @@ export async function requestJson(options) {
                         : JSON.stringify(options.body)
         : undefined;
     const url = buildRequestUrl(options);
-    const headers = createHeaders(token, hasBody, options.headers, options.accept, options.bodyMode, options.contentType);
+    const idempotencyHeader = options.idempotency?.enabled === true && method !== "GET"
+        ? {
+            [options.idempotency.header]: options.idempotency.key ?? options.idempotency.createKey?.() ?? randomUUID()
+        }
+        : {};
+    const headers = createHeaders(token, hasBody, { ...options.headers, ...idempotencyHeader }, options.accept, options.bodyMode, options.contentType);
     const writeStdout = options.writeStdout ?? process.stdout.write.bind(process.stdout);
     const writeStderr = options.writeStderr ?? process.stderr.write.bind(process.stderr);
     const requestLine = `${method} ${redactSensitiveQueryValues(url)}`;
@@ -48,18 +38,12 @@ export async function requestJson(options) {
     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 response = await fetchWithRetries(options, url, {
+        method,
+        headers,
+        body: serializedBody,
+        signal: options.signal
+    });
     const contentType = response.headers.get("content-type");
     const request = createHttpErrorRequest(method, url, headers, options.body);
     const responseHeaders = redactHeaders(serializeHeaders(response.headers));
@@ -69,7 +53,7 @@ export async function requestJson(options) {
             if (options.verbose) {
                 writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders)));
             }
-            return undefined;
+            return formatRawResponseResult(undefined, response, options.rawResponse);
         }
         const body = {
             contentType: contentType ?? options.accept ?? "application/octet-stream",
@@ -80,7 +64,7 @@ export async function requestJson(options) {
         if (options.verbose) {
             writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, body)));
         }
-        return body;
+        return formatRawResponseResult(body, response, options.rawResponse);
     }
     const text = await response.text();
     if (response.ok) {
@@ -88,19 +72,19 @@ export async function requestJson(options) {
             if (options.verbose) {
                 writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders)));
             }
-            return undefined;
+            return formatRawResponseResult(undefined, response, options.rawResponse);
         }
         if (options.responseMode === "text") {
             if (options.verbose) {
                 writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, text)));
             }
-            return text;
+            return formatRawResponseResult(text, response, options.rawResponse);
         }
         if (!isJsonContentType(contentType)) {
             if (options.verbose) {
                 writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, text)));
             }
-            throw new HttpError({
+            throw createHttpError({
                 request,
                 response: {
                     status: response.status,
@@ -119,7 +103,7 @@ export async function requestJson(options) {
             if (options.verbose) {
                 writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, text)));
             }
-            throw new HttpError({
+            throw createHttpError({
                 request,
                 response: {
                     status: response.status,
@@ -133,7 +117,7 @@ export async function requestJson(options) {
         if (options.verbose) {
             writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, body)));
         }
-        return body;
+        return formatRawResponseResult(body, response, options.rawResponse);
     }
     if (response.status === 401 && options.auth === "required") {
         await options.tokenSource.invalidate?.(token).catch(() => undefined);
@@ -142,16 +126,128 @@ export async function requestJson(options) {
     if (options.verbose) {
         writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, body)));
     }
-    throw new HttpError({
+    throw createHttpError({
         request,
         response: {
             status: response.status,
             statusText: response.statusText,
             headers: responseHeaders,
             body
-        }
+        },
+        code: extractErrorCode(body),
+        requestId: response.headers.get("x-request-id") ?? response.headers.get("x-requestid") ?? undefined
     });
 }
+async function fetchWithRetries(options, url, init) {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    const retries = options.retries;
+    const maxRetries = retries?.max ?? 0;
+    let attempt = 0;
+    while (true) {
+        try {
+            const response = await fetchImpl(url, init);
+            if (retries === undefined ||
+                attempt >= maxRetries ||
+                !shouldRetryStatus(response.status, retries.retryOn)) {
+                return response;
+            }
+            await sleepBeforeRetry(response, retries, attempt);
+            attempt += 1;
+        }
+        catch (error) {
+            const classified = classifyNetworkError(error, url) ?? error;
+            if (attempt >= maxRetries || retries === undefined) {
+                throw classified;
+            }
+            await sleepBeforeRetry(undefined, retries, attempt);
+            attempt += 1;
+        }
+    }
+}
+function shouldRetryStatus(status, retryOn) {
+    return retryOn?.includes(status) === true;
+}
+async function sleepBeforeRetry(response, retries, attempt) {
+    const retryAfter = response?.headers.get("retry-after");
+    const delay = parseRetryAfter(retryAfter) ?? calculateBackoffDelay(attempt, retries.random);
+    await (retries.sleep ?? defaultSleep)(delay);
+}
+function parseRetryAfter(value) {
+    if (value === null || value === undefined) {
+        return undefined;
+    }
+    const seconds = Number(value);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+        return seconds * 1000;
+    }
+    const timestamp = Date.parse(value);
+    if (!Number.isNaN(timestamp)) {
+        return Math.max(0, timestamp - Date.now());
+    }
+    return undefined;
+}
+function calculateBackoffDelay(attempt, random) {
+    const base = 100 * 2 ** attempt;
+    return Math.floor(base * (random ?? Math.random)());
+}
+function defaultSleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function formatRawResponseResult(data, response, rawResponse) {
+    return rawResponse === true ? { data, response } : data;
+}
+export async function prepareMultipartFileInputs(requestShape, options) {
+    if (options.bodyMode !== "multipart" ||
+        options.multipartBinaryFields === undefined ||
+        options.multipartBinaryFields.length === 0 ||
+        options.fs === undefined ||
+        options.env === undefined ||
+        requestShape.body === undefined) {
+        return requestShape;
+    }
+    if (requestShape.body === null ||
+        typeof requestShape.body !== "object" ||
+        Array.isArray(requestShape.body)) {
+        return requestShape;
+    }
+    const body = { ...requestShape.body };
+    for (const field of options.multipartBinaryFields) {
+        const value = body[field];
+        if (typeof value !== "string") {
+            continue;
+        }
+        const filePath = resolveUserPath(value, options.env);
+        if (!(await options.fs.exists(filePath))) {
+            continue;
+        }
+        body[field] = {
+            data: await options.fs.readFile(filePath, "base64"),
+            filename: path.basename(filePath) || field
+        };
+    }
+    return {
+        ...requestShape,
+        body
+    };
+}
+export async function writeBinaryResponseOutput(result, outputPath, runtime) {
+    if (outputPath === undefined) {
+        return result;
+    }
+    if (runtime.fs === undefined || runtime.env === undefined) {
+        throw new UserError("Cannot write binary output without a Toolcraft file runtime.");
+    }
+    if (!isBinaryHttpResponse(result)) {
+        throw new UserError("Cannot write an empty binary response to an output path.");
+    }
+    const resolvedOutputPath = resolveUserPath(String(outputPath), runtime.env);
+    await runtime.fs.writeFile(resolvedOutputPath, result.data, { encoding: "base64" });
+    return {
+        output: resolvedOutputPath,
+        byteLength: result.byteLength,
+        contentType: result.contentType
+    };
+}
 function buildRequestUrl(options) {
     const resolvedPath = substitutePathParams(options.path, options.pathParams);
     const baseUrl = new URL(options.baseUrl);
@@ -223,6 +319,22 @@ function decodeBase64Body(body) {
     }
     return Uint8Array.from(Buffer.from(body, "base64")).buffer;
 }
+function decodeMultipartBinaryValue(value, fallbackFilename) {
+    if (typeof value === "string") {
+        return {
+            data: value,
+            filename: fallbackFilename
+        };
+    }
+    if (value !== null &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        typeof value.data === "string" &&
+        typeof value.filename === "string") {
+        return value;
+    }
+    throw new UserError("Multipart binary request fields must be base64 strings or resolved file inputs.");
+}
 function serializeMultipartBody(body, binaryFields = []) {
     if (body === null || typeof body !== "object" || Array.isArray(body)) {
         throw new UserError("Multipart request bodies must be objects.");
@@ -233,7 +345,8 @@ function serializeMultipartBody(body, binaryFields = []) {
         if (value === undefined)
             continue;
         if (binary.has(key)) {
-            form.append(key, new Blob([decodeBase64Body(value)]), key);
+            const file = decodeMultipartBinaryValue(value, key);
+            form.append(key, new Blob([decodeBase64Body(file.data)]), file.filename);
         }
         else if (Array.isArray(value)) {
             for (const item of value)
@@ -245,6 +358,20 @@ function serializeMultipartBody(body, binaryFields = []) {
     }
     return form;
 }
+function resolveUserPath(userPath, env) {
+    if (path.isAbsolute(userPath)) {
+        return path.normalize(userPath);
+    }
+    return path.resolve(env.get("INIT_CWD") ?? process.cwd(), userPath);
+}
+function isBinaryHttpResponse(value) {
+    return (value !== null &&
+        typeof value === "object" &&
+        value.encoding === "base64" &&
+        typeof value.data === "string" &&
+        typeof value.byteLength === "number" &&
+        typeof value.contentType === "string");
+}
 function isQueryObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -358,6 +485,21 @@ function parseResponseBody(text, contentType) {
     }
     return JSON.parse(text);
 }
+function extractErrorCode(body) {
+    if (body === null || typeof body !== "object" || Array.isArray(body)) {
+        return undefined;
+    }
+    const directCode = body.code;
+    if (typeof directCode === "string") {
+        return directCode;
+    }
+    const error = body.error;
+    if (error !== null && typeof error === "object" && !Array.isArray(error)) {
+        const nestedCode = error.code;
+        return typeof nestedCode === "string" ? nestedCode : undefined;
+    }
+    return undefined;
+}
 function isJsonContentType(contentType) {
     if (contentType === null) {
         return false;

package/dist/index.d.ts

@@ -2,16 +2,21 @@ export { defineApiCommand } from "./api-command.js";
 export { defineClient } from "./define-client.js";
 export { generate } from "./generate.js";
 export type { GenerateOptions, GeneratedFile, OpenApiDocument } from "./generate.js";
+export { SUPPORTED_TOOLCRAFT_EDITION, mergeToolcraftConfig, readToolcraftConfig, validateToolcraftConfig } from "./config.js";
+export type { ToolcraftConfig, ToolcraftMethodConfig, ToolcraftResourceConfig } from "./config.js";
+export { diagnose } from "./diagnose.js";
+export { DIAGNOSTIC_CODES, formatDiagnostic, formatDiagnostics } from "./diagnostics.js";
+export type { Diagnostic, DiagnosticSeverity } from "./diagnostics.js";
 export { inspectOpenApiDocument } from "./inspect.js";
 export type { OpenApiInspectionOperation, OpenApiInspectionReport } from "./inspect.js";
 export { inspectOpenApiSource } from "./inspect-source.js";
 export type { InspectOpenApiSourceOptions, OpenApiInspectionSource } from "./inspect-source.js";
 export { renderOpenApiInspection } from "./render-inspection.js";
-export { commandsFromSpec, defineClientFromSpec } from "./runtime.js";
+export { commandsFromSpec, defineClientFromSpec, resolveOpenApiBaseUrl } from "./runtime.js";
 export type { CommandsFromSpecOptions, DefineClientFromSpecOptions, OpenApiDocumentSource } from "./runtime.js";
 export type { DefineClientOptions, DefinedClient, OpenApiClientServices } from "./define-client.js";
 export type { AuthProvider, CommandContributor, TokenSource } from "./auth/types.js";
 export { bearerTokenAuth } from "./auth/bearer-token-auth.js";
 export type { BearerTokenAuthOptions } from "./auth/bearer-token-auth.js";
-export { HttpError, requestJson } from "./http.js";
+export { HttpError, prepareMultipartFileInputs, requestJson, writeBinaryResponseOutput } from "./http.js";
 export type { BinaryHttpResponse, HttpErrorRequest, HttpErrorResponse, HttpRequestOptions, QueryValue } from "./http.js";

package/dist/index.js

@@ -1,9 +1,12 @@
 export { defineApiCommand } from "./api-command.js";
 export { defineClient } from "./define-client.js";
 export { generate } from "./generate.js";
+export { SUPPORTED_TOOLCRAFT_EDITION, mergeToolcraftConfig, readToolcraftConfig, validateToolcraftConfig } from "./config.js";
+export { diagnose } from "./diagnose.js";
+export { DIAGNOSTIC_CODES, formatDiagnostic, formatDiagnostics } from "./diagnostics.js";
 export { inspectOpenApiDocument } from "./inspect.js";
 export { inspectOpenApiSource } from "./inspect-source.js";
 export { renderOpenApiInspection } from "./render-inspection.js";
-export { commandsFromSpec, defineClientFromSpec } from "./runtime.js";
+export { commandsFromSpec, defineClientFromSpec, resolveOpenApiBaseUrl } from "./runtime.js";
 export { bearerTokenAuth } from "./auth/bearer-token-auth.js";
-export { HttpError, requestJson } from "./http.js";
+export { HttpError, prepareMultipartFileInputs, requestJson, writeBinaryResponseOutput } from "./http.js";

package/dist/runtime.d.ts

@@ -9,5 +9,12 @@ export interface CommandsFromSpecOptions {
     fs?: OpenApiSourceFileSystem;
 }
 export type DefineClientFromSpecOptions<TServices extends object = Record<string, never>> = Omit<DefineClientOptions<TServices>, "commands"> & CommandsFromSpecOptions;
+export interface ResolveOpenApiBaseUrlOptions {
+    document: OpenApiDocument;
+    environments?: Record<string, string>;
+    environment?: string;
+    env?: Record<string, string | undefined>;
+}
 export declare function commandsFromSpec(source: OpenApiDocumentSource, options?: CommandsFromSpecOptions): Promise<CommandNode<OpenApiClientServices>[]>;
 export declare function defineClientFromSpec<TServices extends object = Record<string, never>>(spec: OpenApiDocumentSource, options: DefineClientFromSpecOptions<TServices>): Promise<DefinedClient<TServices>>;
+export declare function resolveOpenApiBaseUrl(options: ResolveOpenApiBaseUrlOptions): string | undefined;

package/dist/runtime.js

@@ -1,9 +1,9 @@
 import fs from "node:fs/promises";
-import { defineCommand, defineGroup, S } from "toolcraft";
+import { UserError, defineCommand, defineGroup, S } from "toolcraft";
 import { defineClient } from "./define-client.js";
 import { collectSchemaOptionEntries, collectGeneratedCommands } from "./generate.js";
 import { groupByNoun } from "./group-by-noun.js";
-import { requestJson } from "./http.js";
+import { prepareMultipartFileInputs, requestJson, writeBinaryResponseOutput } from "./http.js";
 import { buildRequestShape, executePreflightBlocks } from "./interpreter.js";
 import { parseOpenApiDocument, readOpenApiSourceText } from "./spec-source.js";
 const RUNTIME_COMMAND_SCOPE = ["cli", "mcp", "sdk"];
@@ -31,6 +31,24 @@ async function resolveDocument(source, options) {
     });
     return parseOpenApiDocument(sourceText, source);
 }
+export function resolveOpenApiBaseUrl(options) {
+    const environments = options.environments;
+    if (environments !== undefined && Object.keys(environments).length > 0) {
+        const selectedName = options.environment ?? options.env?.TOOLCRAFT_OPENAPI_ENV ?? Object.keys(environments)[0];
+        const selectedUrl = selectedName === undefined ? undefined : environments[selectedName];
+        if (selectedUrl !== undefined) {
+            return normalizeBaseUrl(selectedUrl);
+        }
+        if (selectedName !== undefined) {
+            throw new UserError(`Unknown OpenAPI environment ${JSON.stringify(selectedName)}. Available: ${Object.keys(environments).join(", ")}.`);
+        }
+    }
+    const server = options.document.servers?.[0]?.url;
+    return server === undefined ? undefined : normalizeBaseUrl(server);
+}
+function normalizeBaseUrl(value) {
+    return new URL(value).toString().replace(/\/$/, "");
+}
 function createRuntimeGroups(commands) {
     return groupByNoun(commands).map(({ noun, commands: nounCommands }) => defineGroup({
         name: noun,
@@ -49,10 +67,16 @@ function createRuntimeCommand(command) {
     });
 }
 function createRuntimeHandler(command) {
-    return async ({ params, baseUrl, tokenSource, fetch }) => {
+    return async ({ params, baseUrl, tokenSource, fetch, fs, env }) => {
         const resolvedValues = executePreflightBlocks(command.preflightBlocks, params);
         const requestShape = buildRequestShape(command.requestFields, command.sectionRenders, command.optionalSections, params, resolvedValues);
-        return requestJson({
+        const preparedRequestShape = await prepareMultipartFileInputs(requestShape, {
+            bodyMode: command.bodyMode,
+            multipartBinaryFields: command.multipartBinaryFields,
+            fs,
+            env
+        });
+        const result = await requestJson({
             baseUrl: command.baseUrl ?? baseUrl,
             path: command.path,
             method: command.method,
@@ -66,8 +90,9 @@ function createRuntimeHandler(command) {
             fetch,
             dryRun: params.dryRun,
             verbose: params.verbose,
-            ...requestShape
+            ...preparedRequestShape
         });
+        return writeBinaryResponseOutput(result, command.responseMode === "binary" ? params.output : undefined, { fs, env });
     };
 }
 function createRuntimeParamSchema(param) {

package/node_modules/@poe-code/frontmatter/README.md

@@ -0,0 +1,35 @@
+# @poe-code/frontmatter
+
+Shared YAML frontmatter parsing for poe-code packages.
+
+## API
+
+```ts
+import {
+  FrontmatterParseError,
+  parseFrontmatter,
+  parseFrontmatterDocument,
+  stringifyFrontmatter
+} from "@poe-code/frontmatter";
+```
+
+- `parseFrontmatter(source)` returns `{ frontmatter, body }`.
+- `parseFrontmatterDocument(source)` returns `{ frontmatter, body, errors, lineCounter }` for callers that need YAML diagnostics.
+- `stringifyFrontmatter(frontmatter, body)` writes `---` fences, YAML, and the body.
+- `FrontmatterParseError` is thrown for malformed frontmatter, invalid YAML, non-object frontmatter, and stringify failures.
+
+When no leading frontmatter block exists, parsing returns `{ frontmatter: {}, body: source }`.
+The returned `body` is sliced from the original input and is otherwise byte-for-byte unchanged.
+YAML mappings that contain `__proto__` keep it as an own property without changing the object's prototype.
+
+Duplicate mapping keys use YAML's last-wins behavior by default, matching the
+legacy frontmatter readers. Callers that need strict YAML mappings can pass
+`{ uniqueKeys: true }` to `parseFrontmatter` or `parseFrontmatterDocument`.
+
+## Environment
+
+This package reads no environment variables.
+
+## Config
+
+This package has no configuration options.

package/node_modules/@poe-code/frontmatter/dist/fences.d.ts

@@ -0,0 +1,8 @@
+export type FrontmatterBlock = {
+    raw: string;
+    body: string;
+};
+export type SplitFrontmatterResult = FrontmatterBlock | {
+    body: string;
+};
+export declare function splitFrontmatterBlock(source: string): SplitFrontmatterResult;

package/node_modules/@poe-code/frontmatter/dist/fences.js

@@ -0,0 +1,72 @@
+export function splitFrontmatterBlock(source) {
+    const content = source.startsWith("\uFEFF") ? source.slice(1) : source;
+    const opening = readOpeningFence(content);
+    if (opening === undefined) {
+        return { body: source };
+    }
+    const closing = findClosingFence(content, opening.next);
+    if (closing === undefined) {
+        throw new Error("Missing YAML frontmatter end delimiter (---).");
+    }
+    return {
+        raw: content.slice(opening.next, closing.index),
+        body: content.slice(closing.end + closing.lineBreakLength)
+    };
+}
+function readOpeningFence(source) {
+    if (!source.startsWith("---")) {
+        return undefined;
+    }
+    const lineEnd = findLineEnd(source, 0);
+    if (lineEnd.lineBreakLength === 0 || source.slice(0, lineEnd.index) !== "---") {
+        return undefined;
+    }
+    return { next: lineEnd.index + lineEnd.lineBreakLength };
+}
+function findClosingFence(source, start) {
+    let lineStart = start;
+    while (lineStart <= source.length) {
+        const lineEnd = findLineEnd(source, lineStart);
+        if (isClosingFenceLine(source.slice(lineStart, lineEnd.index))) {
+            return {
+                index: lineStart,
+                end: lineEnd.index,
+                lineBreakLength: lineEnd.lineBreakLength
+            };
+        }
+        if (lineEnd.lineBreakLength === 0) {
+            break;
+        }
+        lineStart = lineEnd.index + lineEnd.lineBreakLength;
+    }
+    return undefined;
+}
+function isClosingFenceLine(line) {
+    if (!line.startsWith("---")) {
+        return false;
+    }
+    for (let index = 3; index < line.length; index += 1) {
+        const character = line[index];
+        if (character !== " " && character !== "\t") {
+            return false;
+        }
+    }
+    return true;
+}
+function findLineEnd(source, start) {
+    let index = start;
+    while (index < source.length) {
+        const character = source[index];
+        if (character === "\n") {
+            return { index, lineBreakLength: 1 };
+        }
+        if (character === "\r") {
+            return {
+                index,
+                lineBreakLength: source[index + 1] === "\n" ? 2 : 1
+            };
+        }
+        index += 1;
+    }
+    return { index: source.length, lineBreakLength: 0 };
+}

package/node_modules/@poe-code/frontmatter/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { splitFrontmatterBlock, type FrontmatterBlock, type SplitFrontmatterResult } from "./fences.js";
+export { FrontmatterParseError, parseFrontmatter, parseFrontmatterDocument, type ParsedFrontmatter, type ParsedFrontmatterDocument, type ParseFrontmatterOptions } from "./parse.js";
+export { stringifyFrontmatter } from "./stringify.js";

package/node_modules/@poe-code/frontmatter/dist/index.js

@@ -0,0 +1,3 @@
+export { splitFrontmatterBlock } from "./fences.js";
+export { FrontmatterParseError, parseFrontmatter, parseFrontmatterDocument } from "./parse.js";
+export { stringifyFrontmatter } from "./stringify.js";

package/node_modules/@poe-code/frontmatter/dist/parse.d.ts

@@ -0,0 +1,20 @@
+import { LineCounter } from "yaml";
+export interface ParsedFrontmatter {
+    frontmatter: Record<string, unknown>;
+    body: string;
+}
+export interface ParsedFrontmatterDocument extends ParsedFrontmatter {
+    errors: readonly {
+        message: string;
+        pos?: [number, number];
+    }[];
+    lineCounter: LineCounter;
+}
+export interface ParseFrontmatterOptions {
+    uniqueKeys?: boolean;
+}
+export declare class FrontmatterParseError extends Error {
+    constructor(message: string);
+}
+export declare function parseFrontmatter(source: string, options?: ParseFrontmatterOptions): ParsedFrontmatter;
+export declare function parseFrontmatterDocument(source: string, options?: ParseFrontmatterOptions): ParsedFrontmatterDocument;