@focus-reactive/payload-plugin-translator 0.10.4 → 0.11.1

package/dist/translation-providers/openai/loadOpenAIClient.js

@@ -0,0 +1,79 @@
+import { errorMessageLower, ProviderConfigurationError } from "../shared";
+/**
+ * A literal `import("openai")` is type-resolved like a static import and would put the SDK into the
+ * emitted .d.ts, forcing every consumer to install it. Through a constant it resolves at runtime only.
+ */ const OPENAI_MODULE = "openai";
+const MODULE_NOT_FOUND_CODES = new Set([
+    "ERR_MODULE_NOT_FOUND",
+    "MODULE_NOT_FOUND"
+]);
+/**
+ * Bundlers and test runners re-throw resolution failures in their own shapes, and several drop the
+ * `code` on the way. The wording is the more portable signal, so both are checked.
+ */ const MODULE_NOT_FOUND_MESSAGES = {
+    nodeCjs: "cannot find module",
+    nodeEsm: "cannot find package",
+    viteRollup: "failed to resolve",
+    viteDev: "failed to load url",
+    webpack: "module not found"
+};
+/**
+ * Each runtime's message names two things: what was not found and who imported it. The importer half
+ * is a path inside node_modules/openai, so it must be cut off before searching for "openai".
+ */ const IMPORTER_CLAUSES = {
+    nodeEsm: " imported from ",
+    nodeCjs: "require stack:",
+    vite: " from ",
+    webpack: " in "
+};
+/**
+ * `@vercel/nft` (Vercel builds, Next `output: "standalone"`) resolves `import()` statically and can
+ * follow a module-level constant but not a parameter — silently, so a parameterised specifier gets
+ * `openai` pruned from the deployment and the first production translation reports it missing.
+ */ async function importOpenAISdk() {
+    return await import(OPENAI_MODULE);
+}
+function whatCouldNotBeFound(text) {
+    return Object.values(IMPORTER_CLAUSES).reduce((remaining, clause)=>remaining.split(clause)[0], text);
+}
+/**
+ * Was `moduleSpecifier` itself missing, or one of its dependencies? Exported for its own test; not
+ * public API.
+ */ export function isModuleNotFound(cause, moduleSpecifier) {
+    const text = errorMessageLower(cause);
+    if (text === null) return false;
+    if (!whatCouldNotBeFound(text).includes(moduleSpecifier.toLowerCase())) return false;
+    const code = cause.code;
+    if (typeof code === "string" && MODULE_NOT_FOUND_CODES.has(code)) return true;
+    return Object.values(MODULE_NOT_FOUND_MESSAGES).some((phrase)=>text.includes(phrase));
+}
+/**
+ * Constructs an OpenAI SDK client, importing the `openai` package on every call — callers memoize.
+ * Reached only when a consumer passed `apiKey`; a consumer who injects a `client` never runs this
+ * module.
+ *
+ * @throws ProviderConfigurationError for a missing package, a broken install, or rejected options.
+ */ export async function loadOpenAIClient(options, importSdk = importOpenAISdk) {
+    let sdk;
+    try {
+        sdk = await importSdk();
+    } catch (cause) {
+        if (isModuleNotFound(cause, OPENAI_MODULE)) {
+            throw new ProviderConfigurationError("createOpenAIProvider({ apiKey }) needs the optional `openai` package. Install it, or pass a ready-made `client` instead.", {
+                cause
+            });
+        }
+        throw new ProviderConfigurationError("The `openai` package is installed but failed to load. See this error's `cause`.", {
+            cause
+        });
+    }
+    try {
+        return new sdk.default(options);
+    } catch (cause) {
+        throw new ProviderConfigurationError("The OpenAI client could not be constructed from the given options. See this error's `cause`.", {
+            cause
+        });
+    }
+}
+
+//# sourceMappingURL=loadOpenAIClient.js.map

package/dist/translation-providers/openai/openAIComplete.d.ts

@@ -0,0 +1,39 @@
+import type { CompletionFn } from "../shared";
+import type { OpenAIChatParams, OpenAIClientShape } from "./OpenAI.shapes";
+/**
+ * Sampling parameters. Omitted from the request entirely unless set — several models reject them.
+ * Unset means the model's own defaults; pass `{ temperature: 0 }` for deterministic output.
+ *
+ * @since 0.11.0
+ */
+export type OpenAISamplingParams = Pick<OpenAIChatParams, "temperature" | "top_p" | "frequency_penalty" | "presence_penalty">;
+/**
+ * Which structured-output envelope to send.
+ *
+ * `json_schema` (the default): the reply must satisfy a schema, so a compliant model cannot drop a
+ * field. Older models and some gateways reject it with a 400, and the schema has a per-model
+ * property ceiling a large document can exceed.
+ *
+ * `json_object`: asks only for valid JSON. No ceiling, but a dropped key is then detected by
+ * key-set validation after the fact rather than prevented.
+ *
+ * The README weighs the two and explains how to size a document against the ceiling.
+ *
+ * @since 0.11.0
+ */
+export type OpenAIStructuredOutput = "json_schema" | "json_object";
+/**
+ * The vendor boundary: the only place OpenAI's response shape is read.
+ *
+ * Takes a client you constructed — it never loads the `openai` package — so pair it with
+ * `createTranslationProvider` to build a provider on an SDK version of your own choosing:
+ * `createTranslationProvider({ complete: openAIComplete({ client, model }) })`.
+ *
+ * @since 0.11.0
+ */
+export declare function openAIComplete(args: {
+    client: OpenAIClientShape;
+    model: string;
+    sampling?: OpenAISamplingParams;
+    structuredOutput?: OpenAIStructuredOutput;
+}): CompletionFn;

package/dist/translation-providers/openai/openAIComplete.js

@@ -0,0 +1,84 @@
+import { errorMessageLower, NoContentError, ProviderConfigurationError } from "../shared";
+const SCHEMA_NAME = "translation";
+/**
+ * Did the service reject the request over the schema envelope, and if so, why? The match stays
+ * narrow: a proxy that echoes the request body into an error string would otherwise turn every rate
+ * limit into a configuration problem.
+ */ function classifySchemaRejection(cause) {
+    const text = errorMessageLower(cause);
+    if (text === null) return null;
+    if (!text.includes("response_format") && !text.includes("json_schema")) return null;
+    // "…'response_format' of type 'json_schema' is not supported with this model."
+    if (text.includes("not supported") || text.includes("unsupported")) {
+        return "model-does-not-support";
+    }
+    // "Invalid schema for response_format 'translation': object has too many properties."
+    if (text.includes("invalid schema")) return "schema-rejected";
+    return null;
+}
+/**
+ * The vendor boundary: the only place OpenAI's response shape is read.
+ *
+ * Takes a client you constructed — it never loads the `openai` package — so pair it with
+ * `createTranslationProvider` to build a provider on an SDK version of your own choosing:
+ * `createTranslationProvider({ complete: openAIComplete({ client, model }) })`.
+ *
+ * @since 0.11.0
+ */ export function openAIComplete(args) {
+    const { client, model, sampling, structuredOutput = "json_schema" } = args;
+    return async ({ systemPrompt, userContent, responseSchema, signal })=>{
+        if (structuredOutput === "json_object" && !/json/iu.test(systemPrompt)) {
+            throw new ProviderConfigurationError('With structuredOutput: "json_object", OpenAI requires the word "json" somewhere in the prompt. Your systemPrompt override does not contain it.');
+        }
+        const params = {
+            model,
+            messages: [
+                {
+                    role: "system",
+                    content: systemPrompt
+                },
+                {
+                    role: "user",
+                    content: userContent
+                }
+            ],
+            response_format: structuredOutput === "json_schema" ? {
+                type: "json_schema",
+                json_schema: {
+                    name: SCHEMA_NAME,
+                    strict: true,
+                    schema: responseSchema
+                }
+            } : {
+                type: "json_object"
+            },
+            ...sampling
+        };
+        let result;
+        try {
+            result = await client.chat.completions.create(params, {
+                signal
+            });
+        } catch (cause) {
+            const rejection = structuredOutput === "json_schema" ? classifySchemaRejection(cause) : null;
+            if (rejection === "model-does-not-support") {
+                throw new ProviderConfigurationError(`The model "${model}" does not support the json_schema response format. Pass structuredOutput: "json_object", or choose a model that supports structured outputs.`, {
+                    cause
+                });
+            }
+            if (rejection === "schema-rejected") {
+                throw new ProviderConfigurationError(`OpenAI rejected the generated response schema. This usually means the document has more translatable fields than a strict schema allows. Pass structuredOutput: "json_object", or translate a smaller subtree.`, {
+                    cause
+                });
+            }
+            throw cause;
+        }
+        const content = result.choices[0]?.message?.content;
+        if (!content) {
+            throw new NoContentError("OpenAI returned no content. The reply may have been filtered, or the model produced nothing.");
+        }
+        return content;
+    };
+}
+
+//# sourceMappingURL=openAIComplete.js.map

package/dist/translation-providers/shared/CompletionProvider.provider.d.ts

@@ -0,0 +1,65 @@
+import type { TranslationProvider } from "../../core/domain/translation-providers";
+import type { JsonSchemaObject } from "./buildResponseSchema";
+import type { SystemPromptBuilder } from "./buildSystemPrompt";
+import type { DryRunConfig } from "./runDryRun";
+/**
+ * Everything a transport needs in order to make one translation request.
+ *
+ * @since 0.11.0
+ */
+export type CompletionRequest = {
+    /** Already includes any `systemPrompt` override — send it verbatim, do not rebuild it. */
+    systemPrompt: string;
+    /** The user message: the input serialized as JSON. */
+    userContent: string;
+    /** A JSON Schema requiring exactly the input's keys. Feed it to the service's structured-output mechanism. */
+    responseSchema: JsonSchemaObject;
+    /** Reserved: the port carries no cancellation yet, so this is always `undefined` today. */
+    signal?: AbortSignal;
+};
+/**
+ * Sends one translation request and returns the service's reply as **raw text**.
+ *
+ * Returning text rather than a parsed object is deliberate: parsing and key-set validation stay on
+ * this side of the boundary, so a provider built on this factory cannot accidentally skip them.
+ *
+ * @since 0.11.0
+ */
+export type CompletionFn = (request: CompletionRequest) => Promise<string>;
+/**
+ * Configuration for {@link createTranslationProvider}.
+ *
+ * @since 0.11.0
+ */
+export type TranslationProviderConfig = {
+    complete: CompletionFn;
+    systemPrompt?: SystemPromptBuilder;
+    /**
+     * Simulate translations without calling anything. `true` reverses the text; an object supplies a
+     * transformer and an optional delay.
+     *
+     * @deprecated Supply your own fake `complete` instead. Remove in next major.
+     * See docs/DEPRECATIONS.md#provider-dry-run
+     */
+    dryRun?: boolean | DryRunConfig;
+};
+/**
+ * Builds a complete {@link TranslationProvider} from a single request function.
+ *
+ * Use it when you need a service this package does not ship an adapter for, or when you need full
+ * control of the request body. For OpenAI, `openAIComplete({ client, model })` is a ready-made
+ * `complete` — construct the client yourself.
+ *
+ * @example
+ * ```ts
+ * const provider = createTranslationProvider({
+ *   complete: async ({ systemPrompt, userContent, responseSchema }) => {
+ *     const reply = await myService.chat({ systemPrompt, userContent, schema: responseSchema })
+ *     return reply.text
+ *   },
+ * })
+ * ```
+ *
+ * @since 0.11.0
+ */
+export declare function createTranslationProvider(config: TranslationProviderConfig): TranslationProvider;

package/dist/translation-providers/shared/CompletionProvider.provider.js

@@ -0,0 +1,93 @@
+import { buildResponseSchema } from "./buildResponseSchema";
+import { buildSystemPrompt } from "./buildSystemPrompt";
+import { NoContentError, ProviderConfigurationError, wrapTransportError } from "./errors";
+import { parseAndValidateReply } from "./parseAndValidateReply";
+import { runDryRun } from "./runDryRun";
+const MAX_LOGGED_REPLY_KEYS = 10;
+/** Keys are model output: quoting them stops a newline inside a key from forging log entries. */ function describeReplyKeys(keys) {
+    const shown = keys.slice(0, MAX_LOGGED_REPLY_KEYS).map((key)=>JSON.stringify(key));
+    const rest = keys.length - shown.length;
+    return rest > 0 ? `${shown.join(", ")} and ${rest} more` : shown.join(", ");
+}
+function warnAboutPartialReply(missingInputKeys, unrequestedReplyKeys) {
+    const lead = missingInputKeys.length > 0 ? `The provider's reply did not cover every field. Untranslated indices: ${missingInputKeys.join(", ")}.` : "The provider's reply carried keys that were not requested.";
+    const extra = unrequestedReplyKeys.length > 0 ? ` Unexpected keys ignored: ${describeReplyKeys(unrequestedReplyKeys)}.` : "";
+    console.warn(`[payload-plugin-translator] ${lead}${extra}`);
+}
+async function asConfigurationFailure(what, run) {
+    try {
+        return await run();
+    } catch (cause) {
+        throw new ProviderConfigurationError(`The ${what} threw. See this error's \`cause\`.`, {
+            cause
+        });
+    }
+}
+/** Only the consumer's transform is wrapped — our own loop must not report its bugs as configuration failures. */ function guardTransformer(dryRun) {
+    if (typeof dryRun !== "object" || !dryRun.transform) return dryRun;
+    const { transform } = dryRun;
+    return {
+        ...dryRun,
+        transform: (text)=>asConfigurationFailure("dry-run transformer", ()=>transform(text))
+    };
+}
+/**
+ * Builds a complete {@link TranslationProvider} from a single request function.
+ *
+ * Use it when you need a service this package does not ship an adapter for, or when you need full
+ * control of the request body. For OpenAI, `openAIComplete({ client, model })` is a ready-made
+ * `complete` — construct the client yourself.
+ *
+ * @example
+ * ```ts
+ * const provider = createTranslationProvider({
+ *   complete: async ({ systemPrompt, userContent, responseSchema }) => {
+ *     const reply = await myService.chat({ systemPrompt, userContent, schema: responseSchema })
+ *     return reply.text
+ *   },
+ * })
+ * ```
+ *
+ * @since 0.11.0
+ */ export function createTranslationProvider(config) {
+    const { complete, systemPrompt, dryRun } = config;
+    if (dryRun) {
+        const guarded = guardTransformer(dryRun);
+        return {
+            translate: (input)=>runDryRun(input, guarded)
+        };
+    }
+    return {
+        async translate (input, sourceLng, targetLng) {
+            // A strict response schema with no properties is rejected by the service, so an empty
+            // document must not reach the transport at all.
+            if (Object.keys(input).length === 0) return {};
+            const systemPromptText = await asConfigurationFailure("systemPrompt builder", ()=>buildSystemPrompt({
+                    sourceLng,
+                    targetLng,
+                    override: systemPrompt
+                }));
+            const request = await asConfigurationFailure("serialization of the input", ()=>({
+                    systemPrompt: systemPromptText,
+                    userContent: JSON.stringify(input),
+                    responseSchema: buildResponseSchema(input)
+                }));
+            let raw;
+            try {
+                raw = await complete(request);
+            } catch (cause) {
+                throw wrapTransportError(cause);
+            }
+            if (!raw) {
+                throw new NoContentError("The provider returned an empty reply.");
+            }
+            const { translations, missingInputKeys, unrequestedReplyKeys } = parseAndValidateReply(input, raw);
+            if (missingInputKeys.length > 0 || unrequestedReplyKeys.length > 0) {
+                warnAboutPartialReply(missingInputKeys, unrequestedReplyKeys);
+            }
+            return translations;
+        }
+    };
+}
+
+//# sourceMappingURL=CompletionProvider.provider.js.map

package/dist/translation-providers/shared/buildResponseSchema.d.ts

@@ -0,0 +1,13 @@
+import type { TranslationInput } from "../../core/domain/translation-providers";
+/**
+ * A JSON Schema document, as a plain object — deliberately untyped beyond that, so it can be dropped
+ * into any vendor's response-format envelope.
+ *
+ * @since 0.11.0
+ */
+export type JsonSchemaObject = Record<string, unknown>;
+/**
+ * Builds the response schema for a translation request: exactly the input's keys, all required, no
+ * extras.
+ */
+export declare function buildResponseSchema(input: TranslationInput): JsonSchemaObject;

package/dist/translation-providers/shared/buildResponseSchema.js

@@ -0,0 +1,22 @@
+/**
+ * Builds the response schema for a translation request: exactly the input's keys, all required, no
+ * extras.
+ */ export function buildResponseSchema(input) {
+    const keys = Object.keys(input);
+    const properties = {};
+    for (const key of keys){
+        properties[key] = {
+            type: "string"
+        };
+    }
+    // Strict structured-output modes reject a schema unless every property is listed in `required`
+    // and extras are forbidden.
+    return {
+        type: "object",
+        properties,
+        required: keys,
+        additionalProperties: false
+    };
+}
+
+//# sourceMappingURL=buildResponseSchema.js.map

package/dist/translation-providers/shared/buildSystemPrompt.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Context handed to a {@link SystemPromptBuilder}.
+ *
+ * @since 0.11.0
+ */
+export type SystemPromptContext = {
+    /** Source language code (e.g. 'en', 'de'). Empty when the provider should auto-detect. */
+    sourceLang: string;
+    targetLang: string;
+    defaultPrompt: string;
+};
+/**
+ * Builds a custom system prompt for translation.
+ *
+ * @since 0.11.0
+ */
+export type SystemPromptBuilder = (context: SystemPromptContext) => string;
+/**
+ * Produces the system prompt sent with a translation request.
+ *
+ * The default wording is handed to `systemPrompt` builders as `defaultPrompt`, so consumers extend
+ * this exact string — changing it changes every custom prompt built on it.
+ */
+export declare function buildSystemPrompt(args: {
+    sourceLng: string;
+    targetLng: string;
+    override?: SystemPromptBuilder;
+}): string;

package/dist/translation-providers/shared/buildSystemPrompt.js

@@ -0,0 +1,25 @@
+/**
+ * Context handed to a {@link SystemPromptBuilder}.
+ *
+ * @since 0.11.0
+ */ /**
+ * Produces the system prompt sent with a translation request.
+ *
+ * The default wording is handed to `systemPrompt` builders as `defaultPrompt`, so consumers extend
+ * this exact string — changing it changes every custom prompt built on it.
+ */ export function buildSystemPrompt(args) {
+    const { sourceLng, targetLng, override } = args;
+    const defaultPrompt = `Translate the values from the JSON that the user will send you${sourceLng ? ` from ${sourceLng}` : ""} into ${targetLng}. Keep all JSON keys exactly as they are, only translate the values.
+The response should be a valid JSON object with the same structure and keys as the input, but with translated values.
+Maintain any special formatting, placeholders, or variables within the values if they exist.`;
+    if (override) {
+        return override({
+            sourceLang: sourceLng,
+            targetLang: targetLng,
+            defaultPrompt
+        });
+    }
+    return defaultPrompt;
+}
+
+//# sourceMappingURL=buildSystemPrompt.js.map

package/dist/translation-providers/shared/errors/KeySetMismatchError.d.ts

@@ -0,0 +1,15 @@
+import { TranslationProviderError } from "./TranslationProviderError";
+/**
+ * Nothing in the reply could be applied — either its keys did not overlap the input's, or they did
+ * and none of the values was a string. A partial gap is not an error; see `parseAndValidateReply`.
+ *
+ * @since 0.11.0
+ */
+export declare class KeySetMismatchError extends TranslationProviderError {
+    readonly code: "key-set-mismatch";
+    /** Input keys left without a usable translation. */
+    readonly missingInputKeys: number[];
+    /** Keys the reply carried but nobody asked for — model output, so untrusted text. */
+    readonly unrequestedReplyKeys: string[];
+    constructor(message: string, missingInputKeys: number[], unrequestedReplyKeys: string[], options?: ErrorOptions);
+}

package/dist/translation-providers/shared/errors/KeySetMismatchError.js

@@ -0,0 +1,26 @@
+import { TranslationProviderError } from "./TranslationProviderError";
+/**
+ * Nothing in the reply could be applied — either its keys did not overlap the input's, or they did
+ * and none of the values was a string. A partial gap is not an error; see `parseAndValidateReply`.
+ *
+ * @since 0.11.0
+ */ export class KeySetMismatchError extends TranslationProviderError {
+    code = "key-set-mismatch";
+    /** Input keys left without a usable translation. */ missingInputKeys;
+    /** Keys the reply carried but nobody asked for — model output, so untrusted text. */ unrequestedReplyKeys;
+    constructor(message, missingInputKeys, unrequestedReplyKeys, options){
+        super(message, options);
+        this.missingInputKeys = missingInputKeys;
+        this.unrequestedReplyKeys = unrequestedReplyKeys;
+        // Model-invented strings: enumerable, they would land in `JSON.stringify(error)` and every
+        // structured logger.
+        Object.defineProperty(this, "missingInputKeys", {
+            enumerable: false
+        });
+        Object.defineProperty(this, "unrequestedReplyKeys", {
+            enumerable: false
+        });
+    }
+}
+
+//# sourceMappingURL=KeySetMismatchError.js.map

package/dist/translation-providers/shared/errors/NoContentError.d.ts

@@ -0,0 +1,9 @@
+import { TranslationProviderError } from "./TranslationProviderError";
+/**
+ * The provider produced no usable text — an empty reply, or a response the vendor filtered.
+ *
+ * @since 0.11.0
+ */
+export declare class NoContentError extends TranslationProviderError {
+    readonly code: "no-content";
+}

package/dist/translation-providers/shared/errors/NoContentError.js

@@ -0,0 +1,10 @@
+import { TranslationProviderError } from "./TranslationProviderError";
+/**
+ * The provider produced no usable text — an empty reply, or a response the vendor filtered.
+ *
+ * @since 0.11.0
+ */ export class NoContentError extends TranslationProviderError {
+    code = "no-content";
+}
+
+//# sourceMappingURL=NoContentError.js.map

package/dist/translation-providers/shared/errors/ProviderConfigurationError.d.ts

@@ -0,0 +1,10 @@
+import { TranslationProviderError } from "./TranslationProviderError";
+/**
+ * The provider is configured in a way that cannot work — most often an optional SDK that is not
+ * installed.
+ *
+ * @since 0.11.0
+ */
+export declare class ProviderConfigurationError extends TranslationProviderError {
+    readonly code: "config";
+}

package/dist/translation-providers/shared/errors/ProviderConfigurationError.js

@@ -0,0 +1,11 @@
+import { TranslationProviderError } from "./TranslationProviderError";
+/**
+ * The provider is configured in a way that cannot work — most often an optional SDK that is not
+ * installed.
+ *
+ * @since 0.11.0
+ */ export class ProviderConfigurationError extends TranslationProviderError {
+    code = "config";
+}
+
+//# sourceMappingURL=ProviderConfigurationError.js.map

package/dist/translation-providers/shared/errors/TranslationProviderError.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Failure causes a translation provider can report.
+ *
+ * @since 0.11.0
+ */
+export type TranslationFailureCode = "no-content" | "unparseable-reply" | "key-set-mismatch" | "transport" | "config";
+/**
+ * Base class for every failure a built-in translation provider reports.
+ *
+ * The original failure travels on `cause` and is never interpolated into `message`: a vendor SDK
+ * error can carry an API key, and `message` reaches an HTTP response body.
+ *
+ * @since 0.11.0
+ */
+export declare abstract class TranslationProviderError extends Error {
+    abstract readonly code: TranslationFailureCode;
+    constructor(message: string, options?: ErrorOptions);
+}

package/dist/translation-providers/shared/errors/TranslationProviderError.js

@@ -0,0 +1,21 @@
+/**
+ * Failure causes a translation provider can report.
+ *
+ * @since 0.11.0
+ */ /**
+ * Base class for every failure a built-in translation provider reports.
+ *
+ * The original failure travels on `cause` and is never interpolated into `message`: a vendor SDK
+ * error can carry an API key, and `message` reaches an HTTP response body.
+ *
+ * @since 0.11.0
+ */ export class TranslationProviderError extends Error {
+    constructor(message, options){
+        // Never `this.cause = cause`: an assigned property is enumerable, so JSON.stringify and pino
+        // serialize the vendor error whole — headers and API key with it. `super` installs it non-enumerably.
+        super(message, options);
+        this.name = new.target.name;
+    }
+}
+
+//# sourceMappingURL=TranslationProviderError.js.map

package/dist/translation-providers/shared/errors/TransportError.d.ts

@@ -0,0 +1,10 @@
+import { TranslationProviderError } from "./TranslationProviderError";
+/**
+ * The call to the provider failed — network, auth, rate limit, timeout. The vendor's own error is on
+ * `cause`.
+ *
+ * @since 0.11.0
+ */
+export declare class TransportError extends TranslationProviderError {
+    readonly code: "transport";
+}

package/dist/translation-providers/shared/errors/TransportError.js

@@ -0,0 +1,11 @@
+import { TranslationProviderError } from "./TranslationProviderError";
+/**
+ * The call to the provider failed — network, auth, rate limit, timeout. The vendor's own error is on
+ * `cause`.
+ *
+ * @since 0.11.0
+ */ export class TransportError extends TranslationProviderError {
+    code = "transport";
+}
+
+//# sourceMappingURL=TransportError.js.map

package/dist/translation-providers/shared/errors/UnparseableReplyError.d.ts

@@ -0,0 +1,9 @@
+import { TranslationProviderError } from "./TranslationProviderError";
+/**
+ * The reply was not JSON, or parsed to something that is not an object — arrays included.
+ *
+ * @since 0.11.0
+ */
+export declare class UnparseableReplyError extends TranslationProviderError {
+    readonly code: "unparseable-reply";
+}

package/dist/translation-providers/shared/errors/UnparseableReplyError.js

@@ -0,0 +1,10 @@
+import { TranslationProviderError } from "./TranslationProviderError";
+/**
+ * The reply was not JSON, or parsed to something that is not an object — arrays included.
+ *
+ * @since 0.11.0
+ */ export class UnparseableReplyError extends TranslationProviderError {
+    code = "unparseable-reply";
+}
+
+//# sourceMappingURL=UnparseableReplyError.js.map

package/dist/translation-providers/shared/errors/errorMessageLower.d.ts

@@ -0,0 +1 @@
+export declare function errorMessageLower(cause: unknown): string | null;

package/dist/translation-providers/shared/errors/errorMessageLower.js

@@ -0,0 +1,8 @@
+import { isObject } from "../../../core/kernel/utils/isObject";
+export function errorMessageLower(cause) {
+    if (!isObject(cause)) return null;
+    const message = cause.message;
+    return typeof message === "string" ? message.toLowerCase() : null;
+}
+
+//# sourceMappingURL=errorMessageLower.js.map

package/dist/translation-providers/shared/errors/index.d.ts

@@ -0,0 +1,9 @@
+export { TranslationProviderError } from "./TranslationProviderError";
+export type { TranslationFailureCode } from "./TranslationProviderError";
+export { NoContentError } from "./NoContentError";
+export { UnparseableReplyError } from "./UnparseableReplyError";
+export { KeySetMismatchError } from "./KeySetMismatchError";
+export { TransportError } from "./TransportError";
+export { ProviderConfigurationError } from "./ProviderConfigurationError";
+export { wrapTransportError } from "./wrapTransportError";
+export { errorMessageLower } from "./errorMessageLower";