veryfront 0.1.48 → 0.1.49

package/src/src/discovery/handlers/skill-handler.ts

@@ -0,0 +1,123 @@
+/**
+ * Skill Discovery Handler
+ *
+ * Discovers skills from SKILL.md files in project directories.
+ * This is a parallel discovery path — it does NOT implement DiscoveryHandler<T>
+ * (which expects TypeScript import()). Instead, it operates on markdown files.
+ */
+
+import { exists, readDir, readTextFile } from "../../platform/compat/fs.js";
+import { join } from "../../platform/compat/path/index.js";
+import { agentLogger } from "../../utils/logger/logger.js";
+import { ensureError } from "../../errors/veryfront-error.js";
+import { parseSkillFrontmatter, validateSkillMetadata } from "../../skill/parser.js";
+import { SKILL_MD_FILENAME } from "../../skill/types.js";
+import type { Skill } from "../../skill/index.js";
+import type { FileDiscoveryContext } from "../types.js";
+
+const logger = agentLogger.component("skill-discovery");
+
+export interface SkillDiscoveryError {
+  file: string;
+  error: Error;
+}
+
+export interface SkillDiscoveryResult {
+  skills: Map<string, Skill>;
+  errors: SkillDiscoveryError[];
+}
+
+/**
+ * Discover skills from a directory.
+ *
+ * Scans for subdirectories containing SKILL.md files and parses them
+ * into Skill objects. Uses fsAdapter when available (for VFS/cloud),
+ * falling back to compat layer functions.
+ */
+export async function discoverSkills(
+  dir: string,
+  context: FileDiscoveryContext,
+  verbose?: boolean,
+): Promise<SkillDiscoveryResult> {
+  const skills = new Map<string, Skill>();
+  const errors: SkillDiscoveryError[] = [];
+  const { fsAdapter } = context;
+
+  // Check if directory exists
+  const dirExists = fsAdapter ? await fsAdapter.exists(dir) : await exists(dir);
+
+  if (!dirExists) {
+    if (verbose) {
+      logger.info(`Skills directory does not exist: ${dir}`);
+    }
+    return { skills, errors };
+  }
+
+  // Iterate subdirectories
+  const entries = fsAdapter ? fsAdapter.readDir(dir) : readDir(dir);
+
+  for await (const entry of entries) {
+    if (!entry.isDirectory) continue;
+
+    const skillDir = join(dir, entry.name);
+    const skillMdPath = join(skillDir, SKILL_MD_FILENAME);
+
+    try {
+      // Check if SKILL.md exists
+      const mdExists = fsAdapter ? await fsAdapter.exists(skillMdPath) : await exists(skillMdPath);
+
+      if (!mdExists) {
+        if (verbose) {
+          logger.info(`Skipping ${entry.name}: no ${SKILL_MD_FILENAME}`);
+        }
+        continue;
+      }
+
+      // Read SKILL.md content
+      const content = fsAdapter
+        ? await fsAdapter.readFile(skillMdPath)
+        : await readTextFile(skillMdPath);
+
+      // Parse frontmatter
+      const parsed = await parseSkillFrontmatter(content);
+
+      // Validate metadata (directory name as fallback for skill name)
+      const metadata = validateSkillMetadata(parsed.frontmatter, entry.name);
+
+      // Warn if metadata name differs from directory name, use directory name as ID
+      const skillId = entry.name;
+      if (metadata.name !== entry.name) {
+        logger.warn(
+          `Skill "${metadata.name}" in directory "${entry.name}" — using directory name as ID`,
+        );
+      }
+
+      // Check for duplicate IDs (first wins)
+      if (skills.has(skillId)) {
+        logger.warn(`Duplicate skill "${skillId}" — keeping first registration`);
+        continue;
+      }
+
+      const skill: Skill = {
+        id: skillId,
+        metadata,
+        rootPath: skillDir,
+        ...(fsAdapter && { fsAdapter }),
+      };
+
+      skills.set(skillId, skill);
+
+      if (verbose) {
+        logger.info(`Discovered skill: ${skillId}`);
+      }
+    } catch (error) {
+      errors.push({ file: skillMdPath, error: ensureError(error) });
+
+      if (verbose) {
+        logger.error(`Error loading skill from ${entry.name}:`, error);
+      }
+    }
+  }
+
+  return { skills, errors };
+}

package/src/src/discovery/handlers/task-handler.ts

@@ -10,12 +10,8 @@ export const taskHandler: DiscoveryHandler<TaskDefinition> = {
   typeName: "task",
   validate: (item): item is TaskDefinition => isTaskDefinition(item),
   getId: (_task, file, dir) => {
-    // Derive ID from file path relative to tasks dir
-    let relative = file;
     const prefix = dir.endsWith("/") ? dir : `${dir}/`;
-    if (relative.startsWith(prefix)) {
-      relative = relative.slice(prefix.length);
-    }
+    const relative = file.startsWith(prefix) ? file.slice(prefix.length) : file;
     return relative.replace(/\.(ts|tsx|js|jsx)$/, "");
   },
   register: (_id, task) => task,

package/src/src/discovery/transpiler.ts

@@ -16,6 +16,10 @@ import type { FileSystemAdapter } from "../platform/adapters/base.js";
 import type { FileDiscoveryContext } from "./types.js";
 import { rewriteDiscoveryImports, rewriteForDeno } from "./import-rewriter.js";
 import { wrapWithCurrentContext } from "../platform/adapters/fs/veryfront/multi-project-adapter.js";
+// Static import ensures deno compile includes embedding in the binary.
+// Other modules (agent, tool, etc.) are statically imported elsewhere;
+// embedding is only referenced here.
+import * as embeddingMod from "../embedding/index.js";
 
 const transpileCache = new Map<string, unknown>();
 
@@ -28,13 +32,12 @@ let veryfrontGlobalsInitialized = false;
 async function ensureVeryfrontGlobals(): Promise<void> {
   if (veryfrontGlobalsInitialized || !isDenoCompiled) return;
 
-  const [agentMod, toolMod, platformMod, promptMod, resourceMod, embeddingMod] = await Promise.all([
+  const [agentMod, toolMod, platformMod, promptMod, resourceMod] = await Promise.all([
     import("../agent/index.js"),
     import("../tool/index.js"),
     import("../platform/index.js"),
     import("../prompt/index.js"),
     import("../resource/index.js"),
-    import("../embedding/index.js"),
   ]);
 
   (dntShim.dntGlobalThis as Record<string, unknown>).__VERYFRONT_MODULES__ = {
@@ -204,9 +207,9 @@ export async function importModule(
     },
   });
 
-  if (result.errors?.length) {
+  if (result.errors.length > 0) {
     throw new Error(
-      `Failed to transpile ${filePath}: ${result.errors[0]?.text || "unknown error"}`,
+      `Failed to transpile ${filePath}: ${result.errors[0]?.text ?? "unknown error"}`,
     );
   }
 

package/src/src/discovery/types.ts

@@ -9,6 +9,7 @@ import type { Agent } from "../agent/index.js";
 import type { Resource } from "../resource/index.js";
 import type { Prompt } from "../prompt/index.js";
 import type { Workflow } from "../workflow/index.js";
+import type { Skill } from "../skill/index.js";
 import type { TaskDefinition } from "../task/types.js";
 import type { Platform } from "../platform/core-platform.js";
 import type { FileSystemAdapter } from "../platform/adapters/base.js";
@@ -33,6 +34,7 @@ export interface DiscoveryConfig {
   baseDir: string;
   toolDirs?: string[];
   agentDirs?: string[];
+  skillDirs?: string[];
   resourceDirs?: string[];
   promptDirs?: string[];
   workflowDirs?: string[];
@@ -47,6 +49,7 @@ export interface DiscoveryConfig {
 export interface DiscoveryResult {
   tools: Map<string, Tool>;
   agents: Map<string, Agent>;
+  skills: Map<string, Skill>;
   resources: Map<string, Resource>;
   prompts: Map<string, Prompt>;
   workflows: Map<string, Workflow>;

package/src/src/embedding/resolve.ts

@@ -64,9 +64,7 @@ function autoInitializeFromEnv(): void {
   }
 
   if (!providers.has("local")) {
-    providers.set("local", (id) => {
-      return createLocalEmbeddingModel(id);
-    });
+    providers.set("local", createLocalEmbeddingModel);
   }
 }
 

package/src/src/embedding/upload-handler.ts

@@ -51,8 +51,12 @@ function inferType(file: dntShim.File): string | null {
   return EXT_TO_TYPE[ext ?? ""] ?? null;
 }
 
-function mimeForType(type: string): string {
-  return Object.entries(MIME_TO_TYPE).find(([, v]) => v === type)?.[0] ?? "text/plain";
+const TYPE_TO_MIME: Record<string, string> = Object.fromEntries(
+  Object.entries(MIME_TO_TYPE).map(([mime, type]) => [type, mime]),
+);
+
+function typeToMime(type: string): string {
+  return TYPE_TO_MIME[type] ?? "text/plain";
 }
 
 interface UploadHandlerConfig {
@@ -119,7 +123,7 @@ export function createUploadHandler(
       }
 
       const buffer = await file.arrayBuffer();
-      const text = await loadUpload(buffer, mimeForType(fileType));
+      const text = await loadUpload(buffer, typeToMime(fileType));
       if (!text.trim()) {
         return dntShim.Response.json(
           { error: "No text could be extracted from file" },

package/src/src/embedding/upload-store.ts

@@ -170,10 +170,10 @@ export function uploadStore(config: UploadStoreConfig): UploadStore {
           createdAt: Date.now(),
         };
 
-        const chunkRecords: StoredChunk[] = chunks.map((text, i) => ({
+        const chunkRecords: StoredChunk[] = chunks.map((chunkText, i) => ({
           id: dntShim.crypto.randomUUID(),
           uploadId,
-          text,
+          text: chunkText,
           embedding: [], // filled lazily on first search
           index: i,
         }));
@@ -282,10 +282,10 @@ export function uploadStore(config: UploadStoreConfig): UploadStore {
           });
 
           data.chunks.push(
-            ...chunks.map((text, i) => ({
+            ...chunks.map((chunkText, i) => ({
               id: dntShim.crypto.randomUUID(),
               uploadId,
-              text,
+              text: chunkText,
               embedding: [] as number[],
               index: i,
             })),

package/src/src/errors/error-registry.ts

@@ -1,4 +1,4 @@
-import { defineError } from "./types.js";
+import { defineError, type ErrorCategory } from "./types.js";
 
 // =============================================================================
 // CONFIG - Configuration & environment errors
@@ -789,7 +789,7 @@ export function getErrorBySlug(slug: ErrorSlug) {
 /**
  * Get all errors in a category
  */
-export function getErrorsByCategory(category: string) {
+export function getErrorsByCategory(category: ErrorCategory) {
   return Object.values(ERROR_REGISTRY).filter((error) => error.category === category);
 }
 

package/src/src/errors/http-error.ts

@@ -9,9 +9,13 @@
 import * as dntShim from "../../_dnt.shims.js";
 
 
-import { type ErrorCategory, type RFC9457Response, VeryfrontError } from "./types.js";
+import {
+  type ErrorCategory,
+  type RegisteredError,
+  type RFC9457Response,
+  VeryfrontError,
+} from "./types.js";
 import { getErrorMessage } from "./veryfront-error.js";
-import type { RegisteredError } from "./types.js";
 
 /**
  * Content-Type header for RFC 9457 responses
@@ -83,7 +87,7 @@ export function createProblemResponse(params: {
  * Check if an error is a VeryfrontError with slug-based identity
  */
 export function isVeryfrontError(error: unknown): error is VeryfrontError {
-  return error instanceof VeryfrontError && typeof (error as VeryfrontError).slug === "string";
+  return error instanceof VeryfrontError;
 }
 
 /**

package/src/src/errors/middleware/cli-error-boundary.ts

@@ -33,7 +33,20 @@ interface ColorFormatter {
  * Check if output is a TTY (supports colors)
  */
 function isTTY(): boolean {
-  return dntShim.Deno.stdout.isTerminal?.() ?? false;
+  const deno = dntShim.dntGlobalThis as {
+    Deno?: {
+      stdout?: { isTerminal?: () => boolean };
+    };
+    process?: {
+      stdout?: { isTTY?: boolean };
+    };
+  };
+
+  if (typeof deno.Deno?.stdout?.isTerminal === "function") {
+    return deno.Deno.stdout.isTerminal();
+  }
+
+  return deno.process?.stdout?.isTTY ?? false;
 }
 
 /**
@@ -210,5 +223,18 @@ export function cliErrorBoundarySync(
  * Exit the process with a status code
  */
 function exit(code: number): never {
-  dntShim.Deno.exit(code);
+  const runtime = dntShim.dntGlobalThis as {
+    Deno?: { exit?: (code: number) => never };
+    process?: { exit?: (code: number) => never };
+  };
+
+  if (typeof runtime.Deno?.exit === "function") {
+    runtime.Deno.exit(code);
+  }
+
+  if (typeof runtime.process?.exit === "function") {
+    runtime.process.exit(code);
+  }
+
+  throw new Error(`Failed to exit with code ${code}`);
 }

package/src/src/errors/middleware/wrap-unknown.ts

@@ -55,16 +55,6 @@ export function wrapUnknownError(
   });
 }
 
-/**
- * Check if an error is already a VeryfrontError
- *
- * @param error - Any error value
- * @returns True if the error is a VeryfrontError instance
- */
-export function isVeryfrontError(error: unknown): error is VeryfrontError {
-  return error instanceof VeryfrontError;
-}
-
 /**
  * Wrap an error with additional context
  *

package/src/src/errors/veryfront-error.ts

@@ -132,15 +132,6 @@ export function fromError(error: unknown): VeryfrontErrorData | null {
   return context as VeryfrontErrorData;
 }
 
-export function logError(
-  error: VeryfrontErrorData,
-  logger?: { error: (msg: string, ...args: unknown[]) => void },
-): void {
-  const log = logger ?? console;
-  const context = "context" in error ? error.context : undefined;
-  log.error(`[${error.type}] ${error.message}`, context ?? {});
-}
-
 /**
  * Extract error message from any error type
  */

package/src/src/html/styles-builder/css-hash-cache.ts

@@ -17,8 +17,11 @@ import { serverLogger } from "../../utils/index.js";
 import { withSpan } from "../../observability/tracing/otlp-setup.js";
 import { SpanNames } from "../../observability/tracing/span-names.js";
 import { hashCSS } from "./candidate-extractor.js";
-import { buildCSSCacheEntry, parseCSSCacheEntry } from "./tailwind-compiler-utils.js";
-import { resolveStylesheet } from "./tailwind-compiler-utils.js";
+import {
+  buildCSSCacheEntry,
+  parseCSSCacheEntry,
+  resolveStylesheet,
+} from "./tailwind-compiler-utils.js";
 
 const logger = serverLogger.component("tailwind");
 

package/src/src/html/styles-builder/plugin-loader.ts

@@ -52,6 +52,49 @@ try {
   __esModule: true,
 };
 
+function isRealDenoRuntime(): boolean {
+  return typeof dntShim.Deno !== "undefined" && typeof dntShim.Deno.version === "object";
+}
+
+function encodeToBase64(source: string): string {
+  const bufferCtor = (dntShim.dntGlobalThis as {
+    Buffer?: {
+      from: (input: string, encoding: string) => { toString: (encoding: string) => string };
+    };
+  }).Buffer;
+
+  if (bufferCtor?.from) {
+    return bufferCtor.from(source, "utf8").toString("base64");
+  }
+
+  const bytes = new TextEncoder().encode(source);
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+
+async function importBundledModule(code: string): Promise<unknown> {
+  if (!isRealDenoRuntime()) {
+    const dataUrl = `data:text/javascript;base64,${encodeToBase64(code)}`;
+    return await import(dataUrl);
+  }
+
+  const tempPath = await dntShim.Deno.makeTempFile({ prefix: "vf_tw_plugin_", suffix: ".mjs" });
+  await dntShim.Deno.writeTextFile(tempPath, code);
+  logger.debug("Wrote plugin to temp file", { path: tempPath });
+
+  try {
+    return await import(`file://${tempPath}`);
+  } finally {
+    await dntShim.Deno.remove(tempPath).catch((error) => {
+      logger.error("Failed to clean up temp plugin file", {
+        path: tempPath,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    });
+  }
+}
+
 /**
  * Dynamically load a module from esm.sh in a compiled Deno binary.
  *
@@ -111,21 +154,7 @@ export async function loadModuleFromEsmSh(packageName: string): Promise<unknown>
     "(globalThis.__localStorageShim||(globalThis.__localStorageShim={getItem:()=>null,setItem:()=>{},length:0}))",
   );
 
-  // Step 5: Write to temp file and import
-  const tempPath = `/tmp/tw_plugin_${dntShim.crypto.randomUUID()}.mjs`;
-  await dntShim.Deno.writeTextFile(tempPath, code);
-  logger.debug("Wrote plugin to temp file", { path: tempPath });
-
-  try {
-    return await import(`file://${tempPath}`);
-  } finally {
-    await dntShim.Deno.remove(tempPath).catch((error) => {
-      logger.error("Failed to clean up temp plugin file", {
-        path: tempPath,
-        error: error instanceof Error ? error.message : String(error),
-      });
-    });
-  }
+  return await importBundledModule(code);
 }
 
 export async function loadPlugin(
@@ -151,12 +180,20 @@ export async function loadPlugin(
       logger.debug("Loading plugin from node_modules", { id });
       try {
         mod = await import(id);
-      } catch {
-        const errorMsg = `Failed to load plugin "${id}": plugin not installed`;
-        logger.warn("Plugin not installed", { id });
-        pluginErrors.set(id, errorMsg);
-        pluginCache.set(id, null);
-        throw new Error(errorMsg);
+      } catch (importError) {
+        logger.debug("Plugin not found in node_modules, falling back to esm.sh", { id });
+        try {
+          mod = await loadModuleFromEsmSh(id);
+        } catch {
+          const errorMsg = `Failed to load plugin "${id}": plugin not installed`;
+          logger.warn("Plugin not installed", {
+            id,
+            error: importError instanceof Error ? importError.message : String(importError),
+          });
+          pluginErrors.set(id, errorMsg);
+          pluginCache.set(id, null);
+          throw new Error(errorMsg);
+        }
       }
     }
 

package/src/src/html/styles-builder/tailwind-compiler-cache.ts

@@ -47,12 +47,19 @@ async function getTailwindBaseCSS(): Promise<string> {
   const url = getTailwindCSSUrl();
   logger.debug("Fetching base CSS", { url });
 
-  const response = await dntShim.fetch(url);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch Tailwind CSS: ${response.status} ${response.statusText}`);
+  try {
+    const response = await dntShim.fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch Tailwind CSS: ${response.status} ${response.statusText}`);
+    }
+    tailwindBaseCSS = await response.text();
+  } catch (error) {
+    logger.warn("Failed to fetch Tailwind base CSS, using empty fallback", {
+      error: error instanceof Error ? error.message : String(error),
+    });
+    tailwindBaseCSS = "";
   }
 
-  tailwindBaseCSS = await response.text();
   return tailwindBaseCSS;
 }
 

package/src/src/html/utils.ts

@@ -37,30 +37,6 @@ const DEFAULT_VERSIONS: DetectedVersions = {
   veryfront: VERYFRONT_VERSION,
 };
 
-export async function detectVersions(projectDir: string): Promise<DetectedVersions> {
-  try {
-    const { createFileSystem } = await import("../platform/compat/fs.js");
-    const fs = createFileSystem();
-    const content = await fs.readTextFile(`${projectDir}/package.json`);
-    const pkg = JSON.parse(content) as {
-      dependencies?: Record<string, string>;
-      devDependencies?: Record<string, string>;
-    };
-
-    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-
-    // Use shared resolver for React version (ensures consistency with module server)
-    const reactVersion = await resolveProjectReactVersion({ projectDir });
-
-    return {
-      react: reactVersion,
-      veryfront: deps.veryfront ? stripSemverRange(deps.veryfront) : DEFAULT_VERSIONS.veryfront,
-    };
-  } catch {
-    return DEFAULT_VERSIONS;
-  }
-}
-
 type CdnProvider = "esm.sh" | "unpkg" | "jsdelivr";
 
 // Platform utilities served from local module server to match SSR behavior.
@@ -220,10 +196,6 @@ function getCdnImportMap(
   return (CDN_IMPORT_MAP_FACTORIES[provider] ?? getEsmShImportMap)(versions);
 }
 
-function getDefaultHTMLImportMap(): Record<string, string> {
-  return getEsmShImportMap(DEFAULT_VERSIONS);
-}
-
 async function resolveVersions(
   projectDir: string,
   config?: VeryfrontConfig,
@@ -314,11 +286,6 @@ export async function buildImportMapJson(
   return JSON.stringify({ imports }, null, 2);
 }
 
-export function buildImportMapJsonSync(importMap?: Record<string, string>): string {
-  const imports = importMap ?? getDefaultHTMLImportMap();
-  return JSON.stringify({ imports }, null, 2);
-}
-
 export function shouldDisableLayout(frontmatter?: Record<string, unknown>): boolean {
   return frontmatter?.layout === false || frontmatter?.layout === "false";
 }

package/src/src/modules/component-registry/registry.ts

@@ -164,9 +164,6 @@ export class ComponentRegistry {
     return new Map(this.components);
   }
 
-  /**
-   * Loader accessor for compatibility with older tests; loader is not used in this registry.
-   */
   getLoader(): ComponentLoader | undefined {
     return undefined;
   }

package/src/src/modules/server/websocket-handler.ts

@@ -65,7 +65,7 @@ export function setupWebSocketHandlers(
         return;
       }
 
-      let message: any;
+      let message: { type?: string };
       try {
         message = JSON.parse(event.data);
       } catch (parseError) {

package/src/src/oauth/handlers/callback-handler.ts

@@ -14,7 +14,7 @@ import {
 } from "../../config/environment-config.js";
 import { type EnvReader, OAuthService } from "../providers/base.js";
 import { memoryTokenStore } from "../token-store/memory.js";
-import type { OAuthServiceConfig, TokenStore } from "../types.js";
+import type { OAuthServiceConfig, OAuthState, TokenStore } from "../types.js";
 
 const logger = baseLogger.component("o-auth");
 
@@ -37,6 +37,9 @@ export interface OAuthCallbackHandlerOptions {
   /** Custom error callback */
   onError?: (serviceId: string, error: string) => void | Promise<void>;
 
+  /** Skip state validation for providers that don't return state */
+  skipStateValidation?: boolean;
+
   /** EnvironmentConfig for test isolation (defaults to getEnvironmentConfig()) */
   env?: EnvironmentConfig;
 
@@ -55,6 +58,7 @@ export function createOAuthCallbackHandler(
     errorRedirect = "/",
     onSuccess,
     onError,
+    skipStateValidation = false,
     env = getEnvironmentConfig(),
     envReader = getEnv,
   } = options;
@@ -106,12 +110,20 @@ export function createOAuthCallbackHandler(
 
     if (!code) return handleError(appUrl, "no_code");
 
-    let oauthState: Awaited<ReturnType<TokenStore["getState"]>> | null = null;
+    let oauthState: OAuthState | null = null;
+
+    if (!skipStateValidation && !state) {
+      return handleError(appUrl, "invalid_state", "Missing state parameter", {
+        serviceId: config.serviceId,
+      });
+    }
+
     if (state) {
       oauthState = await tokenStore.getState(state);
-      if (!oauthState) {
-        logger.warn("Invalid or expired state", { serviceId: config.serviceId });
-        // Continue anyway - some providers don't properly return state
+      if (!skipStateValidation && !oauthState) {
+        return handleError(appUrl, "invalid_state", "Invalid or expired state", {
+          serviceId: config.serviceId,
+        });
       }
     }
 

package/src/src/oauth/providers/base.ts

@@ -141,7 +141,7 @@ export class OAuthProvider {
     body: URLSearchParams,
     clientId: string,
     clientSecret: string,
-  ): Promise<{ response: dntShim.Response; data: any }> {
+  ): Promise<{ response: dntShim.Response; data: Record<string, unknown> }> {
     const response = await dntShim.fetch(this.config.tokenUrl, {
       method: "POST",
       headers: this.buildTokenHeaders(clientId, clientSecret),
@@ -174,8 +174,8 @@ export class OAuthProvider {
       if (!response.ok) {
         return {
           success: false,
-          error: data.error || errorFallback,
-          errorDescription: data.error_description ||
+          error: (data.error as string) || errorFallback,
+          errorDescription: (data.error_description as string) ||
             (errorDescriptionFallback ? errorDescriptionFallback(response.status) : undefined),
         };
       }