mulink 1.0.3 → 1.0.5

package/dist/lib/{chunk-IVMVPQUK.js → chunk-7Y66DW7M.js}

@@ -1032,8 +1032,8 @@ import { cache } from 'react'
  * We use dynamic imports to avoid bundling them in the client
  */
 let serverOnlyModules: {
-  cookies?: () => import('next/headers').ReadonlyRequestCookies
-  headers?: () => import('next/headers').Headers
+  cookies?: () => Awaited<ReturnType<typeof import('next/headers').cookies>>
+  headers?: () => Awaited<ReturnType<typeof import('next/headers').headers>>
   after?: (fn: () => void | Promise<void>) => void
   updateTag?: (tag: string) => void
 } | null = null
@@ -1336,12 +1336,14 @@ export class BaseApiClient {
       
       // Try external auth service
       ${this.configuration.auth?.enabled ? `try {
-        const { ${tokenGetter} } = await import('${authPath}')
-        const session = await ${tokenGetter}()
-        
-        if (session?.accessToken) {
-          getAuthHeaders.Authorization = \`Bearer \${session.accessToken}\`
-          return getAuthHeaders
+        const authModule = await import('${authPath}').catch(() => null)
+        if (authModule && authModule.${tokenGetter}) {
+          const session = await authModule.${tokenGetter}()
+          
+          if (session?.accessToken) {
+            getAuthHeaders.Authorization = \`Bearer \${session.accessToken}\`
+            return getAuthHeaders
+          }
         }
       } catch (error) {
         // Auth not available or error accessing
@@ -1540,7 +1542,8 @@ export class BaseApiClient {
       const requestPromise = this.executeRequestInternal<TData>(
         method, url, body, headers, fetchOptions, timeout, retries, 
         retryDelay, retryCondition, validateResponse, skipAuth, 
-        responseSchema, requestId, [...this.middleware, ...middleware]
+        responseSchema, requestId, [...this.middleware, ...middleware],
+        cacheTags, revalidate, connection, updateTag
       )
       
       requestCache.set(dedupeKey, requestPromise)
@@ -1556,7 +1559,8 @@ export class BaseApiClient {
     return this.executeRequestInternal<TData>(
       method, url, body, headers, fetchOptions, timeout, retries,
       retryDelay, retryCondition, validateResponse, skipAuth,
-      responseSchema, requestId, [...this.middleware, ...middleware]
+      responseSchema, requestId, [...this.middleware, ...middleware],
+      cacheTags, revalidate, connection, updateTag
     )
   }
 
@@ -1575,7 +1579,11 @@ export class BaseApiClient {
     skipAuth: boolean,
     responseSchema?: z.ZodSchema<TData>,
     requestId?: string,
-    middleware: RequestMiddleware[] = []
+    middleware: RequestMiddleware[] = [],
+    cacheTags: string[] = [],
+    revalidate?: number | false,
+    connection?: 'keep-alive' | 'close',
+    updateTag?: (tag: string) => void
   ): Promise<ClientResponse<TData>> {
     const startTime = Date.now()
 
@@ -1662,7 +1670,7 @@ export class BaseApiClient {
             
             if (tagUpdater && typeof window === 'undefined') {
               // Update cache tags on server-side only
-              cacheTags.forEach(tag => {
+              cacheTags.forEach((tag: string) => {
                 try {
                   tagUpdater(tag)
                 } catch (error) {
@@ -2549,13 +2557,23 @@ var SchemaGenerator = class {
     const result = [];
     const schemaMap = /* @__PURE__ */ new Map();
     const dependencyGraph = /* @__PURE__ */ new Map();
+    const enumSchemas = [];
+    const otherSchemas = [];
     for (const schema of schemas) {
+      const isEnum = this.isEnumSchema(schema);
+      if (isEnum) {
+        enumSchemas.push(schema);
+      } else {
+        otherSchemas.push(schema);
+      }
+    }
+    for (const schema of [...enumSchemas, ...otherSchemas]) {
       if (!schemaMap.has(schema.name)) {
         schemaMap.set(schema.name, schema);
         dependencyGraph.set(schema.name, /* @__PURE__ */ new Set());
       }
     }
-    for (const schema of schemas) {
+    for (const schema of [...enumSchemas, ...otherSchemas]) {
       const dependencies = this.findSchemaDependencies(schema);
       for (const dep of dependencies) {
         if (schemaMap.has(dep)) {
@@ -2585,13 +2603,25 @@ var SchemaGenerator = class {
       visiting.delete(schemaName);
       visited.add(schemaName);
     }, "visit");
-    for (const schema of schemaMap.values()) {
+    for (const schema of enumSchemas) {
+      if (!visited.has(schema.name)) {
+        visit(schema.name);
+      }
+    }
+    for (const schema of otherSchemas) {
       if (!visited.has(schema.name)) {
         visit(schema.name);
       }
     }
     return result;
   }
+  isEnumSchema(schema) {
+    if (!schema.schema || !schema.schema._def) {
+      return false;
+    }
+    const def = schema.schema._def;
+    return def.typeName === "ZodEnum";
+  }
   findSchemaDependencies(schema) {
     const dependencies = [];
     const schemaObj = schema.schema;
@@ -2673,7 +2703,7 @@ var SchemaGenerator = class {
       schemaExports.push(...endpointSchemas.exports);
     }
     const validationHelpers = this.generateValidationHelpers();
-    const content = this.removeUnusedCode([
+    const contentWithImports = [
       ...imports,
       "",
       "// Generated schemas from OpenAPI specification",
@@ -2683,7 +2713,13 @@ var SchemaGenerator = class {
       "",
       validationHelpers,
       ""
-    ].join("\n"));
+    ].join("\n");
+    let content = this.removeUnusedCode(contentWithImports);
+    if (!content.includes('import { z } from "zod"') && !content.includes("import { z } from 'zod'")) {
+      content = `import { z } from "zod"
+
+${content}`;
+    }
     return {
       path: "schemas/index.ts",
       content,
@@ -3032,7 +3068,11 @@ export const errorMessages = {
     const lines = content.split("\n");
     const cleanedLines = [];
     const usedIdentifiers = /* @__PURE__ */ new Set();
+    usedIdentifiers.add("z");
     for (const line of lines) {
+      if (line.includes("z.")) {
+        usedIdentifiers.add("z");
+      }
       const assignments = line.match(/(\w+)\s*[:=]/g);
       if (assignments) {
         assignments.forEach((match) => {
@@ -3047,6 +3087,9 @@ export const errorMessages = {
           usedIdentifiers.add(identifier);
         });
       }
+      if (line.includes("z.infer")) {
+        usedIdentifiers.add("z");
+      }
     }
     for (const line of lines) {
       if (line.trim() === "" || line.trim().startsWith("//")) {
@@ -3054,6 +3097,10 @@ export const errorMessages = {
         continue;
       }
       if (line.includes("import") && line.includes("from")) {
+        if (line.includes('from "zod"') || line.includes("from 'zod'")) {
+          cleanedLines.push(line);
+          continue;
+        }
         const importMatch = line.match(/import\s*\{([^}]+)\}/);
         if (importMatch) {
           const imports = importMatch[1].split(",").map((imp) => imp.trim());
@@ -3082,6 +3129,166 @@ var ActionGenerator = class {
   static {
     __name(this, "ActionGenerator");
   }
+  get loggingEnabled() {
+    return this.configuration.dev?.logging !== false;
+  }
+  get validationEnabled() {
+    return this.configuration.dev?.validation !== false;
+  }
+  get commentsEnabled() {
+    return this.configuration.generation?.comments !== false;
+  }
+  get documentationEnabled() {
+    return this.configuration.generation?.documentation !== false;
+  }
+  commentLine(text, indent = 2) {
+    if (!this.commentsEnabled) {
+      return "";
+    }
+    return `${" ".repeat(indent)}// ${text}
+`;
+  }
+  buildDocBlock(endpoint, featuresDescription) {
+    if (!this.documentationEnabled) {
+      return "";
+    }
+    const summary = endpoint.summary || endpoint.description || `${endpoint.method} ${endpoint.path}`;
+    return `/**
+ * ${summary}
+ * @generated from ${endpoint.method} ${endpoint.path}
+ * Features: ${featuresDescription}
+ */
+`;
+  }
+  buildUtilityFunctions() {
+    const parts = [];
+    if (this.commentsEnabled) {
+      parts.push("// Utility functions for enhanced server actions");
+    }
+    parts.push(`async function getClientInfo() {
+  const headersList = await headers()
+  const userAgent = headersList.get('user-agent') || 'unknown'
+  const ip = headersList.get('x-forwarded-for') || headersList.get('x-real-ip') || 'unknown'
+  
+  return { userAgent, ip }
+}`);
+    if (this.validationEnabled) {
+      parts.push(`async function validateAndSanitizeInput<T>(schema: z.ZodSchema<T>, input: unknown): Promise<T> {
+  try {
+    return await schema.parseAsync(input)
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      const errorMessages = error.issues.map(issue => {
+        const path = issue.path.length > 0 ? \`\${issue.path.join('.')}: \` : ''
+        return \`\${path}\${issue.message}\`
+      }).join(', ')
+      throw new ActionError(\`Input validation failed: \${errorMessages}\`, 'VALIDATION_ERROR')
+    }
+    throw new ActionError('Invalid input format', 'VALIDATION_ERROR')
+  }
+}`);
+    }
+    const actionErrorBlock = `${this.commentsEnabled ? "// Enhanced error handling with context\n" : ""}class ActionExecutionError extends ActionError {
+  constructor(
+    message: string,
+    public readonly context: {
+      endpoint: string
+      method: string
+      timestamp: number
+    },
+    public readonly originalError?: unknown
+  ) {
+    super(message, 'EXECUTION_ERROR')
+  }
+}`;
+    parts.push(actionErrorBlock);
+    if (this.loggingEnabled) {
+      const loggingHeader = this.commentsEnabled ? "// Logging utility for server actions\n" : "";
+      parts.push(`${loggingHeader}async function logActionExecution(
+  action: string,
+  success: boolean,
+  duration: number,
+  context?: Record<string, any>
+) {
+  if (process.env.NODE_ENV === 'development') {
+    console.log(\`[ACTION] \${action} - \${success ? 'SUCCESS' : 'FAILED'} (\${duration}ms)\`, context)
+  }
+  
+${this.commentsEnabled ? "  // In production, send to your logging service\n  // await analytics.track('server_action_executed', { action, success, duration, ...context })" : ""}
+}`);
+    }
+    return parts.join("\n\n");
+  }
+  buildCombinedValidationSnippet(operationName, schemaName) {
+    if (this.validationEnabled) {
+      return `
+${this.commentLine("Validate and sanitize input payload", 6)}      const { body, params } = await validateAndSanitizeInput(${schemaName}, parsedInput)
+      const validatedBody = body
+      const validatedParams = params as z.infer<typeof ${operationName}ParamsSchema>`;
+    }
+    return `
+${this.commentLine("Runtime validation disabled - trusting provided payload", 6)}      const { body, params } = parsedInput as {
+        body: z.infer<typeof ${operationName}RequestSchema>
+        params: z.infer<typeof ${operationName}ParamsSchema>
+      }
+      const validatedBody = body
+      const validatedParams = params`;
+  }
+  buildBodyValidationSnippet(schemaName) {
+    if (schemaName === "z.void()") {
+      return "";
+    }
+    if (this.validationEnabled) {
+      return `
+${this.commentLine("Validate and sanitize request body", 6)}      const validatedBody = await validateAndSanitizeInput(${schemaName}, parsedInput)`;
+    }
+    return `
+${this.commentLine("Runtime validation disabled - trusting request body", 6)}      const validatedBody = parsedInput as z.infer<typeof ${schemaName}>`;
+  }
+  buildParamsValidationSnippet(operationName, schemaName) {
+    if (schemaName === "z.void()") {
+      return "";
+    }
+    if (this.validationEnabled) {
+      return `
+${this.commentLine("Validate and sanitize parameters", 6)}      const validatedParams = await validateAndSanitizeInput(${schemaName}, parsedInput) as z.infer<typeof ${operationName}ParamsSchema>`;
+    }
+    return `
+${this.commentLine("Runtime validation disabled - trusting parameters", 6)}      const validatedParams = parsedInput as z.infer<typeof ${operationName}ParamsSchema>`;
+  }
+  buildSuccessLoggingBlock(actionName, endpoint, indent, isStreaming = false) {
+    if (!this.loggingEnabled) {
+      return "";
+    }
+    if (isStreaming) {
+      return `
+${this.commentLine("Background tasks (Next.js 15 feature)", indent)}${" ".repeat(indent)}after(async () => {
+${this.commentLine("Perform background tasks after response is sent", indent + 2)}${" ".repeat(indent + 2)}await logActionExecution('${actionName}', true, Date.now() - startTime, {
+${" ".repeat(indent + 4)}method: '${endpoint.method}',
+${" ".repeat(indent + 4)}path: '${endpoint.path}'
+${" ".repeat(indent + 2)}})
+${" ".repeat(indent)}})`;
+    }
+    return `
+${this.commentLine("Log successful execution", indent)}${" ".repeat(indent)}const duration = Date.now() - startTime
+${" ".repeat(indent)}await logActionExecution('${actionName}', true, duration, {
+${" ".repeat(indent + 2)}method: '${endpoint.method}',
+${" ".repeat(indent + 2)}path: '${endpoint.path}'
+${" ".repeat(indent)}})`;
+  }
+  buildErrorLoggingBlock(actionName, endpoint, indent) {
+    if (!this.loggingEnabled) {
+      return "";
+    }
+    return `
+${" ".repeat(indent)}const duration = Date.now() - startTime
+
+${this.commentLine("Enhanced error logging", indent)}${" ".repeat(indent)}await logActionExecution('${actionName}', false, duration, {
+${" ".repeat(indent + 2)}method: '${endpoint.method}',
+${" ".repeat(indent + 2)}path: '${endpoint.path}',
+${" ".repeat(indent + 2)}error: error instanceof Error ? error.message : 'Unknown error'
+${" ".repeat(indent)}})`;
+  }
   buildImportPath(relativePath) {
     const outputDirectory = this.configuration.outputDir || "generated";
     const cleanPath = relativePath.startsWith("/") ? relativePath.slice(1) : relativePath;
@@ -3134,7 +3341,7 @@ var ActionGenerator = class {
         ...hasStreaming ? ["import { after } from 'next/server'"] : [],
         "import { headers } from 'next/headers'",
         `import { apiClient } from '${clientImport}'`,
-        `import { ${usesAuth || hasRateLimit ? "authActionClient" : "actionClientWithMeta"}, ActionError } from '${safeActionImport}'`,
+        `import { actionClientWithMeta${usesAuth || hasRateLimit ? ", authActionClient" : ""}, ActionError } from '${safeActionImport}'`,
         ...schemaImportsString ? [`import {
   ${schemaImportsString}
 } from '${schemasImport}'`] : [],
@@ -3146,8 +3353,7 @@ var ActionGenerator = class {
         ] : []
       ].filter(Boolean).join("\n");
       const rateLimitSetup = hasRateLimit ? `
-// Rate limiting setup
-const redis = new Redis({
+${this.commentsEnabled ? "// Rate limiting setup\n" : ""}const redis = new Redis({
   url: process.env.UPSTASH_REDIS_REST_URL!,
   token: process.env.UPSTASH_REDIS_REST_TOKEN!,
 })
@@ -3157,60 +3363,7 @@ const ratelimit = new Ratelimit({
   limiter: Ratelimit.slidingWindow(10, '1 m'),
   analytics: true,
 })` : "";
-      const utilityFunctions = `
-// Utility functions for enhanced server actions
-async function getClientInfo() {
-  const headersList = await headers()
-  const userAgent = headersList.get('user-agent') || 'unknown'
-  const ip = headersList.get('x-forwarded-for') || headersList.get('x-real-ip') || 'unknown'
-  
-  return { userAgent, ip }
-}
-
-async function validateAndSanitizeInput<T>(schema: z.ZodSchema<T>, input: unknown): Promise<T> {
-  try {
-    return await schema.parseAsync(input)
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      const errorMessages = error.issues.map(issue => {
-        const path = issue.path.length > 0 ? \`\${issue.path.join('.')}: \` : ''
-        return \`\${path}\${issue.message}\`
-      }).join(', ')
-      throw new ActionError(\`Input validation failed: \${errorMessages}\`, 'VALIDATION_ERROR')
-    }
-    throw new ActionError('Invalid input format', 'VALIDATION_ERROR')
-  }
-}
-
-// Enhanced error handling with context
-class ActionExecutionError extends ActionError {
-  constructor(
-    message: string,
-    public readonly context: {
-      endpoint: string
-      method: string
-      timestamp: number
-    },
-    public readonly originalError?: unknown
-  ) {
-    super(message, 'EXECUTION_ERROR')
-  }
-}
-
-// Logging utility for server actions
-async function logActionExecution(
-  action: string,
-  success: boolean,
-  duration: number,
-  context?: Record<string, any>
-) {
-  if (process.env.NODE_ENV === 'development') {
-    console.log(\`[ACTION] \${action} - \${success ? 'SUCCESS' : 'FAILED'} (\${duration}ms)\`, context)
-  }
-  
-  // In production, send to your logging service
-  // await analytics.track('server_action_executed', { action, success, duration, ...context })
-}`;
+      const utilityFunctions = this.buildUtilityFunctions();
       const content = `${imports}
 ${rateLimitSetup}
 ${utilityFunctions}
@@ -3227,8 +3380,8 @@ ${actions}`;
         }
       });
     }
-    const indexContent = `// Auto-generated actions index
-${Object.keys(endpointsByTag).map((tag) => `export * from './${toValidIdentifier(tag)}'`).join("\n")}`;
+    const indexHeader = this.commentsEnabled ? "// Auto-generated actions index\n" : "";
+    const indexContent = `${indexHeader}${Object.keys(endpointsByTag).map((tag) => `export * from './${toValidIdentifier(tag)}'`).join("\n")}`;
     generatedFiles.push({
       path: "actions/index.ts",
       content: indexContent,
@@ -3277,54 +3430,48 @@ ${Object.keys(endpointsByTag).map((tag) => `export * from './${toValidIdentifier
         body: ${operationName}RequestSchema,
         params: ${operationName}ParamsSchema
       })`;
-      parameterProcessing = `
-    // Validate and sanitize input
-    const { body, params } = await validateAndSanitizeInput(${schemaName}, parsedInput)
-    const validatedBody = body
-    const validatedParams = params as any`;
+      parameterProcessing = this.buildCombinedValidationSnippet(operationName, schemaName);
       requestOptionsParams = this.buildRequestOptions(pathParameters, queryParameters, true, true);
     } else if (hasRequestBody) {
       schemaName = `${operationName}RequestSchema`;
-      parameterProcessing = `
-    // Validate and sanitize request body
-    const validatedBody = await validateAndSanitizeInput(${schemaName}, parsedInput)`;
+      parameterProcessing = this.buildBodyValidationSnippet(schemaName);
       requestOptionsParams = `body: validatedBody`;
     } else if (hasAnyParams) {
       schemaName = `${operationName}ParamsSchema`;
-      parameterProcessing = `
-    // Validate and sanitize parameters
-    const validatedParams = await validateAndSanitizeInput(${schemaName}, parsedInput) as any`;
+      parameterProcessing = this.buildParamsValidationSnippet(operationName, schemaName);
       requestOptionsParams = this.buildRequestOptions(pathParameters, queryParameters, false, true);
     } else {
       schemaName = "z.void()";
       parameterProcessing = "";
       requestOptionsParams = "";
     }
+    const parsedInputType = hasRequestBody || hasAnyParams ? `z.infer<typeof ${schemaName}>` : "void";
+    const ctxType = requiresAuth || hasRateLimit ? "{ user?: any; ratelimit?: { remaining: number } }" : "any";
+    const ctxDeclaration = requiresAuth || hasRateLimit ? `ctx: ${ctxType}` : "ctx?: any";
+    const actionArgsType = `{ parsedInput: ${parsedInputType}; ${ctxDeclaration} }`;
     const clientName = requiresAuth || hasRateLimit ? "authActionClient" : "actionClientWithMeta";
     const rateLimitCode = hasRateLimit ? `
-    // Rate limiting
-    const { userAgent, ip } = await getClientInfo()
-    const identifier = \`\${ip}-\${userAgent}\`
-    const { success, limit, reset, remaining } = await ratelimit.limit(identifier)
-    
-    if (!success) {
-      throw new ActionError(
-        \`Rate limit exceeded. Try again in \${Math.round((reset - Date.now()) / 1000)} seconds.\`,
-        'RATE_LIMIT_EXCEEDED'
-      )
-    }` : "";
+${this.commentLine("Rate limiting", 6)}      const { userAgent, ip } = await getClientInfo()
+      const identifier = \`\${ip}-\${userAgent}\`
+      const { success, limit, reset, remaining } = await ratelimit.limit(identifier)
+      
+      if (!success) {
+        throw new ActionError(
+          \`Rate limit exceeded. Try again in \${Math.round((reset - Date.now()) / 1000)} seconds.\`,
+          'RATE_LIMIT_EXCEEDED'
+        )
+      }` : "";
     const revalidationCode = revalidationTags.length > 0 ? revalidationTags.map(
-      (tag) => `      updateTag('${tag}')
-      console.log('Updated tag: ${tag}')`
+      (tag) => `      updateTag('${tag}')${this.loggingEnabled ? `
+      console.log('Updated tag: ${tag}')` : ""}`
     ).join("\n") : "";
     const kebabActionName = actionName.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
     if (isQuery) {
-      return `/**
- * ${endpoint.summary || endpoint.description || `${endpoint.method} ${endpoint.path}`}
- * @generated from ${endpoint.method} ${endpoint.path}
- * Features: React cache, input validation, error handling
- */
-export const ${actionName} = cache(
+      const docBlock = this.buildDocBlock(
+        endpoint,
+        "React cache, input validation, error handling"
+      );
+      return `${docBlock}export const ${actionName} = cache(
   ${clientName}
     .metadata({
       name: "${kebabActionName}",
@@ -3332,7 +3479,7 @@ export const ${actionName} = cache(
       rateLimit: { requests: ${endpoint.metadata.rateLimit?.requests || 10}, window: "${endpoint.metadata.rateLimit?.window || "1m"}" }` : ""}
     })
     .schema(${schemaName})
-    .action(async ({ parsedInput, ctx }) => {
+    .action(async ({ parsedInput, ctx }: ${actionArgsType}) => {
       const startTime = Date.now()
       
       try {${rateLimitCode}${parameterProcessing}
@@ -3347,23 +3494,11 @@ export const ${actionName} = cache(
           }
         })
         
-        // Log successful execution
-        const duration = Date.now() - startTime
-        await logActionExecution('${actionName}', true, duration, {
-          method: '${endpoint.method}',
-          path: '${endpoint.path}'
-        })
+${this.buildSuccessLoggingBlock(actionName, endpoint, 8)}
         
         return response.data
       } catch (error) {
-        const duration = Date.now() - startTime
-        
-        // Enhanced error logging
-        await logActionExecution('${actionName}', false, duration, {
-          method: '${endpoint.method}',
-          path: '${endpoint.path}',
-          error: error instanceof Error ? error.message : 'Unknown error'
-        })
+${this.buildErrorLoggingBlock(actionName, endpoint, 8)}
         
         // Throw enhanced error with context
         throw new ActionExecutionError(
@@ -3380,50 +3515,37 @@ export const ${actionName} = cache(
 )`;
     }
     const redirectCode = `
-        // Handle potential redirects based on response
-        if (response.status === 201 && response.headers.get('location')) {
+${this.commentLine("Handle potential redirects based on response", 8)}        if (response.status === 201 && response.headers.get('location')) {
           const location = response.headers.get('location')!
           redirect(location)
         }`;
     const streamingCode = `
-        // Handle streaming responses
-        if (response.headers.get('content-type')?.includes('text/stream')) {
-          // Process streaming response
-          return response.data
+${this.commentLine("Handle streaming responses", 8)}        if (response.headers.get('content-type')?.includes('text/stream')) {
+${this.commentLine("Process streaming response", 10)}          return response.data
         }`;
     const fileUploadCode = hasFileUpload ? uploadStrategy === "external" && uploadProvider === "vercel-blob" ? `
-        // Handle file uploads with Vercel Blob
-        if (validatedBody && typeof validatedBody === 'object' && 'file' in validatedBody) {
+${this.commentLine("Handle file uploads with Vercel Blob", 8)}        if (validatedBody && typeof validatedBody === 'object' && 'file' in validatedBody) {
           const file = (validatedBody as any).file as File
           const blob = await put(file.name, file, { access: 'public' })
           Object.assign(validatedBody, { fileUrl: blob.url })
         }` : uploadStrategy === "external" && uploadProvider === "uploadthing" ? `
-        // Handle file uploads with UploadThing
-        // Note: UploadThing requires a separate route handler setup
-        // See: https://docs.uploadthing.com/getting-started/appdir
-        if (validatedBody && typeof validatedBody === 'object' && 'file' in validatedBody) {
-          // UploadThing file handling should be done via their route handler
-          // This is a placeholder - implement according to UploadThing docs
-        }` : `
-        // Handle file uploads with standard FormData
-        if (validatedBody && typeof validatedBody === 'object' && 'file' in validatedBody) {
-          // Standard file upload handling
-          const file = (validatedBody as any).file as File
-          // Process file with compression and validation if enabled
-        }` : "";
-    return `/**
- * ${endpoint.summary || endpoint.description || `${endpoint.method} ${endpoint.path}`}
- * @generated from ${endpoint.method} ${endpoint.path}
- * Features: Input validation, revalidation, error handling
- */
-export const ${actionName} = ${clientName}
+${this.commentLine("Handle file uploads with UploadThing", 8)}${this.commentLine("UploadThing requires a separate route handler setup", 8)}${this.commentLine("See: https://docs.uploadthing.com/getting-started/appdir", 8)}        if (validatedBody && typeof validatedBody === 'object' && 'file' in validatedBody) {
+${this.commentLine("UploadThing file handling should be done via their route handler", 10)}${this.commentLine("This is a placeholder - implement according to UploadThing docs", 10)}        }` : `
+${this.commentLine("Handle file uploads with standard FormData", 8)}        if (validatedBody && typeof validatedBody === 'object' && 'file' in validatedBody) {
+${this.commentLine("Standard file upload handling", 10)}          const file = (validatedBody as any).file as File
+${this.commentLine("Process file with compression and validation if enabled", 10)}        }` : "";
+    const mutationDocBlock = this.buildDocBlock(
+      endpoint,
+      "Input validation, revalidation, error handling"
+    );
+    return `${mutationDocBlock}export const ${actionName} = ${clientName}
   .metadata({
     name: "${kebabActionName}",
     requiresAuth: ${requiresAuth}${hasRateLimit ? `,
     rateLimit: { requests: ${endpoint.metadata.rateLimit?.requests || 10}, window: "${endpoint.metadata.rateLimit?.window || "1m"}" }` : ""}
   })
   .schema(${schemaName})
-  .action(async ({ parsedInput, ctx }) => {
+  .action(async ({ parsedInput, ctx }: ${actionArgsType}) => {
     const startTime = Date.now()
     
     try {${rateLimitCode}${parameterProcessing}${fileUploadCode}
@@ -3438,33 +3560,13 @@ export const ${actionName} = ${clientName}
         }
       })${streamingCode}${redirectCode}
 
-      // Revalidate cache after successful mutation
-${revalidationCode}
-      
-      // Background tasks (Next.js 15 feature)
-      ${isStreaming ? `after(async () => {
-        // Perform background tasks after response is sent
-        await logActionExecution('${actionName}', true, Date.now() - startTime, {
-          method: '${endpoint.method}',
-          path: '${endpoint.path}'
-        })
-      })` : `// Log successful execution
-      const duration = Date.now() - startTime
-      await logActionExecution('${actionName}', true, duration, {
-        method: '${endpoint.method}',
-        path: '${endpoint.path}'
-      })`}
+      ${revalidationCode ? `${this.commentLine("Revalidate cache after successful mutation", 6)}${revalidationCode}
+` : ""}
+${this.buildSuccessLoggingBlock(actionName, endpoint, 6, isStreaming)}
       
       return response.data
     } catch (error) {
-      const duration = Date.now() - startTime
-      
-      // Enhanced error logging
-      await logActionExecution('${actionName}', false, duration, {
-        method: '${endpoint.method}',
-        path: '${endpoint.path}',
-        error: error instanceof Error ? error.message : 'Unknown error'
-      })
+${this.buildErrorLoggingBlock(actionName, endpoint, 6)}
       
       // Throw enhanced error with context
       throw new ActionExecutionError(
@@ -3623,7 +3725,6 @@ var HookGenerator = class {
       if (hasInfiniteQueries) reactQueryImports.push("useInfiniteQuery");
       const reactImports = [];
       if (hasMutations) reactImports.push("useOptimistic", "useTransition");
-      if (hasQueries) reactImports.push("useCallback");
       const imports = [
         "'use client'",
         "",
@@ -3735,19 +3836,19 @@ ${Object.keys(endpointsByTag).map((tag) => `export * from './${toValidIdentifier
  * @returns useQuery result with data of type ${returnType}
  */
 export function ${hookName}(${parameterTypes.length > 0 ? `${parameterTypes.join(", ")}, ` : ""}options?: ${optionsType}) {
-  const [searchParams, setSearchParams] = useQueryStates(searchParamsParser)
+  const [searchParams] = useQueryStates(searchParamsParser)
   const { initialData, ...restOptions } = options ?? {}
   
   return useQuery({
     queryKey: [...${queryKey}, searchParams],
-    queryFn: useCallback(async ({ signal }: { signal?: AbortSignal }) => {
+    queryFn: async ({ signal }: { signal?: AbortSignal }) => {
       try {
         const result = await ${actionName}(${actionCallParams.replace(queryParamObject, "{ ...searchParams }")})
         return result
       } catch (error) {
         handleActionError(error)
       }
-    }, [searchParams]),
+    },
     staleTime: ${staleTime},
     gcTime: ${staleTime * 2}, // React Query v5: gcTime replaces cacheTime
     enabled: ${enabledCondition} && (options?.enabled ?? true),
@@ -3757,14 +3858,14 @@ export function ${hookName}(${parameterTypes.length > 0 ? `${parameterTypes.join
     refetchInterval: options?.refetchInterval, // Optional polling interval
     initialDataUpdatedAt: initialData ? Date.now() : undefined,
     // React Query v5: placeholderData replaces keepPreviousData
-    placeholderData: (previousData) => previousData,
-    retry: (failureCount, error) => {
+    placeholderData: (previousData: ${returnType} | undefined) => previousData,
+    retry: (failureCount: number, error: Error) => {
       // Don't retry on 4xx errors (client errors)
       if (error instanceof Error && error.message.includes('4')) return false
       // Retry up to 3 times for network/server errors
       return failureCount < 3
     },
-    initialData: initialData as any,
+    initialData: initialData as ${returnType} | undefined,
     ...restOptions
   })
 }
@@ -3779,15 +3880,15 @@ export function ${hookName.replace("use", "useInfinite")}(${parameterTypes.lengt
 
   return useInfiniteQuery({
     queryKey: [...${queryKey}, 'infinite', searchParams],
-    queryFn: useCallback(async ({ pageParam = 1, signal }: { pageParam?: number; signal?: AbortSignal }) => {
+    queryFn: async ({ pageParam = 1, signal }: { pageParam?: number; signal?: AbortSignal }) => {
       try {
         const result = await ${actionName}(${actionCallParams.replace(queryParamObject, "{ ...searchParams, page: pageParam, limit: searchParams.limit }")})
         return result
       } catch (error) {
         handleActionError(error)
       }
-    }, [searchParams]),
-    getNextPageParam: (lastPage: any, allPages) => {
+    },
+    getNextPageParam: (lastPage: ${returnType}, allPages: ${returnType}[]) => {
       if (lastPage?.hasMore || (Array.isArray(lastPage) && lastPage.length === searchParams.limit)) {
         return allPages.length + 1
       }
@@ -3800,9 +3901,9 @@ export function ${hookName.replace("use", "useInfinite")}(${parameterTypes.lengt
     refetchOnReconnect: true,
     refetchOnMount: 'always',
     initialDataUpdatedAt: initialData ? Date.now() : undefined,
-    placeholderData: (previousData) => previousData,
+    placeholderData: (previousData: ${returnType} | undefined) => previousData,
     retry: 3,
-    initialData: initialData as any,
+    initialData: initialData as ${returnType} | undefined,
     ...restOptions
   })
 }
@@ -3816,12 +3917,12 @@ export function ${hookName.replace("use", "useSuspense")}(${parameterTypes.lengt
 
   return useSuspenseQuery({
     queryKey: ${queryKey},
-    queryFn: useCallback(async () => {
+    queryFn: async () => {
       const result = await ${actionName}(${actionCallParams})
       return result
-    }, []),
+    },
     staleTime: ${staleTime},
-    initialData: initialData as any,
+    initialData: initialData as ${returnType} | undefined,
     ...restOptions
   })
 }`;
@@ -3836,14 +3937,14 @@ export function ${hookName}(${parameterTypes.length > 0 ? `${parameterTypes.join
 
   return useQuery({
     queryKey: ${queryKey},
-    queryFn: useCallback(async ({ signal }: { signal?: AbortSignal }) => {
+    queryFn: async ({ signal }: { signal?: AbortSignal }) => {
       try {
         const result = await ${actionName}(${actionCallParams})
         return result
       } catch (error) {
         handleActionError(error)
       }
-    }, []),
+    },
     staleTime: ${staleTime},
     gcTime: ${staleTime * 2}, // React Query v5: gcTime replaces cacheTime
     enabled: ${enabledCondition} && (options?.enabled ?? true),
@@ -3853,14 +3954,14 @@ export function ${hookName}(${parameterTypes.length > 0 ? `${parameterTypes.join
     refetchInterval: options?.refetchInterval, // Optional polling interval
     initialDataUpdatedAt: initialData ? Date.now() : undefined,
     // React Query v5: placeholderData replaces keepPreviousData
-    placeholderData: (previousData) => previousData,
-    retry: (failureCount, error) => {
+    placeholderData: (previousData: ${returnType} | undefined) => previousData,
+    retry: (failureCount: number, error: Error) => {
       // Don't retry on 4xx errors (client errors)
       if (error instanceof Error && error.message.includes('4')) return false
       // Retry up to 3 times for network/server errors
       return failureCount < 3
     },
-    initialData: initialData as any,
+    initialData: initialData as ${returnType} | undefined,
     ...restOptions
   })
 }
@@ -3874,12 +3975,12 @@ export function ${hookName.replace("use", "useSuspense")}(${parameterTypes.lengt
 
   return useSuspenseQuery({
     queryKey: ${queryKey},
-    queryFn: useCallback(async () => {
+    queryFn: async () => {
       const result = await ${actionName}(${actionCallParams})
       return result
-    }, []),
+    },
     staleTime: ${staleTime},
-    initialData: initialData as any,
+    initialData: initialData as ${returnType} | undefined,
     ...restOptions
   })
 }`;
@@ -3910,8 +4011,6 @@ export function ${hookName.replace("use", "useSuspense")}(${parameterTypes.lengt
     const relatedQueries = this.findRelatedQueries(endpoint, context);
     const invalidationCode = this.buildInvalidationCode(endpoint, relatedQueries, invalidationTags);
     const cancelQueriesCode = this.buildCancelQueriesCode(endpoint, relatedQueries);
-    const snapshotCode = this.buildSnapshotCode(endpoint, relatedQueries);
-    const rollbackCode = this.buildRollbackCode(endpoint, relatedQueries);
     return `/**
  * Optimized mutation hook for ${endpoint.method} ${endpoint.path}
  * Features: Optimistic updates, smart invalidation, error handling
@@ -3932,24 +4031,22 @@ export function ${hookName}(options?: {
     mutationFn: async (variables: ${inputType}): Promise<${outputType}> => {
       try {
         const result = await ${actionName}(${variablesParam === "undefined" ? "" : "variables"})
-        return result.data || ({} as any)
+        return (result ?? ({} as ${outputType}))
       } catch (error) {
         handleActionError(error)
       }
     },
     
-    onMutate: async (variables) => {
+    onMutate: async (variables: ${inputType}) => {
 ${cancelQueriesCode}
-      
-${snapshotCode}
-      
+
       // Optimistic update (if provided)
       if (options?.optimisticUpdate) {
         const optimisticValue = options.optimisticUpdate(variables)
         setOptimisticData(optimisticValue)
       }
       
-      return { ${this.getSnapshotReturnNames(relatedQueries)} }
+      return {}
     },
     
     onSuccess: (data, variables) => {
@@ -3958,17 +4055,11 @@ ${snapshotCode}
         toast.success('${this.getSuccessMessage(endpoint)}')
       }
       
-      // Invalidate and refetch related queries
-${invalidationCode}
-      
       // Custom success handler
       options?.onSuccess?.(data, variables)
     },
     
-    onError: (error, variables, context) => {
-      // Rollback optimistic update
-${rollbackCode}
-      
+    onError: (error: Error, variables: ${inputType}) => {
       // Show error toast
       if (options?.showToast !== false) {
         toast.error(error.message || '${this.getErrorMessage(endpoint)}')
@@ -3978,7 +4069,7 @@ ${rollbackCode}
       options?.onError?.(error as Error, variables)
     },
     
-    onSettled: () => {
+    onSettled: async () => {
       // Always refetch after error or success
 ${invalidationCode}
     }
@@ -4004,103 +4095,81 @@ ${invalidationCode}
       return [];
     }
     const relatedQueries = [];
-    const mutationPath = endpoint.path;
+    const seen = /* @__PURE__ */ new Set();
     const mutationTag = endpoint.tags[0];
-    const pathSegments = mutationPath.split("/").filter(Boolean);
+    const mutationSegments = this.getResourceSegments(endpoint.path);
+    const mutationResource = mutationSegments[0];
     context.schema.endpoints.forEach((queryEndpoint) => {
       if (queryEndpoint.method !== "GET") return;
-      const queryPath = queryEndpoint.path;
+      const queryId = queryEndpoint.operationId || queryEndpoint.id;
+      if (seen.has(queryId)) return;
       const queryTag = queryEndpoint.tags[0];
-      if (queryTag === mutationTag) {
+      const querySegments = this.getResourceSegments(queryEndpoint.path);
+      const queryResource = querySegments[0];
+      if (mutationTag && queryTag === mutationTag) {
         relatedQueries.push(queryEndpoint);
+        seen.add(queryId);
         return;
       }
-      const querySegments = queryPath.split("/").filter(Boolean);
-      if (pathSegments.length >= 2 && querySegments.length >= 2) {
-        const baseMatch = pathSegments.slice(0, 2).join("/") === querySegments.slice(0, 2).join("/");
-        if (baseMatch) {
-          relatedQueries.push(queryEndpoint);
-        }
+      if (mutationResource && queryResource && mutationResource === queryResource) {
+        relatedQueries.push(queryEndpoint);
+        seen.add(queryId);
       }
     });
     return relatedQueries;
   }
+  getResourceSegments(path3) {
+    return path3.split("/").filter(Boolean).filter((segment) => segment.toLowerCase() !== "api" && !/^v\d+/i.test(segment));
+  }
   /**
    * Build invalidation code for related queries
    */
   buildInvalidationCode(endpoint, relatedQueries, invalidationTags) {
-    const invalidations = [];
+    const invalidations = /* @__PURE__ */ new Set();
     relatedQueries.forEach((queryEndpoint) => {
-      const queryKey = this.generateQueryKey(queryEndpoint);
-      invalidations.push(`      queryClient.invalidateQueries({ queryKey: ${queryKey} })`);
+      const queryKeyPrefix = toActionName(queryEndpoint.operationId || queryEndpoint.id);
+      invalidations.add(`queryClient.invalidateQueries({ queryKey: ['${queryKeyPrefix}'] })`);
     });
     invalidationTags.forEach((tag) => {
-      if (!invalidations.some((inv) => inv.includes(`'${tag}'`))) {
-        invalidations.push(`      queryClient.invalidateQueries({ queryKey: ['${tag}'] })`);
-      }
+      invalidations.add(`queryClient.invalidateQueries({ queryKey: ['${tag}'] })`);
     });
-    if (invalidations.length === 0) {
+    if (invalidations.size === 0) {
       const inferredKey = this.inferQueryKeyFromPath(endpoint);
       if (inferredKey) {
-        invalidations.push(`      queryClient.invalidateQueries({ queryKey: ${inferredKey} })`);
+        invalidations.add(`queryClient.invalidateQueries({ queryKey: ${inferredKey} })`);
       }
     }
-    return invalidations.length > 0 ? invalidations.join("\n") : "      // No specific cache invalidation needed";
+    if (invalidations.size === 0) {
+      return "      // No specific cache invalidation needed";
+    }
+    if (invalidations.size === 1) {
+      const [statement] = Array.from(invalidations);
+      return `      await ${statement}`;
+    }
+    return `      await Promise.all([
+        ${Array.from(invalidations).join(",\n        ")}
+      ])`;
   }
   /**
    * Build cancel queries code
+   * Uses query key patterns to cancel all related queries regardless of parameters
    */
   buildCancelQueriesCode(endpoint, relatedQueries) {
-    const cancels = [];
+    const cancels = /* @__PURE__ */ new Set();
     relatedQueries.forEach((queryEndpoint) => {
-      const queryKey = this.generateQueryKey(queryEndpoint);
-      cancels.push(`      await queryClient.cancelQueries({ queryKey: ${queryKey} })`);
-    });
-    return cancels.length > 0 ? cancels.join("\n") : "      // No queries to cancel";
-  }
-  /**
-   * Build snapshot code for rollback
-   */
-  buildSnapshotCode(endpoint, relatedQueries) {
-    if (relatedQueries.length === 0) {
-      return "      // No queries to snapshot";
-    }
-    const snapshots = [];
-    relatedQueries.forEach((queryEndpoint, index) => {
-      const queryKey = this.generateQueryKey(queryEndpoint);
-      const varName = `previous${this.toPascalCase(toActionName(queryEndpoint.operationId || queryEndpoint.id))}`;
-      snapshots.push(`      const ${varName} = queryClient.getQueryData(${queryKey})`);
+      const queryKeyPrefix = toActionName(queryEndpoint.operationId || queryEndpoint.id);
+      cancels.add(`queryClient.cancelQueries({ queryKey: ['${queryKeyPrefix}'] })`);
     });
-    return snapshots.join("\n");
-  }
-  /**
-   * Build rollback code
-   */
-  buildRollbackCode(endpoint, relatedQueries) {
-    if (relatedQueries.length === 0) {
-      return "      // No queries to rollback";
+    if (cancels.size === 0) {
+      return "      // No queries to cancel";
     }
-    const rollbacks = [];
-    relatedQueries.forEach((queryEndpoint) => {
-      const queryKey = this.generateQueryKey(queryEndpoint);
-      const varName = `previous${this.toPascalCase(toActionName(queryEndpoint.operationId || queryEndpoint.id))}`;
-      rollbacks.push(`      if (context?.${varName}) {
-        queryClient.setQueryData(${queryKey}, context.${varName})
-      }`);
-    });
-    return rollbacks.join("\n");
-  }
-  /**
-   * Get snapshot return names for context
-   */
-  getSnapshotReturnNames(relatedQueries) {
-    if (relatedQueries.length === 0) {
-      return "previousData: null";
+    if (cancels.size === 1) {
+      const [statement] = Array.from(cancels);
+      return `      await ${statement}`;
     }
-    return relatedQueries.map((queryEndpoint) => {
-      const varName = `previous${this.toPascalCase(toActionName(queryEndpoint.operationId || queryEndpoint.id))}`;
-      return `${varName}`;
-    }).join(", ");
+    return `      await Promise.all([
+        ${Array.from(cancels).join(",\n        ")}
+      ])`;
   }
   /**
    * Infer query key from mutation path
@@ -4258,8 +4327,8 @@ export function useBridgeQuery<TData = unknown, TError = Error>(
     refetchOnWindowFocus: true,
     refetchOnReconnect: true,
     refetchOnMount: 'always',
-    placeholderData: (previousData) => previousData,
-    retry: (failureCount, error) => {
+    placeholderData: (previousData: TData | undefined) => previousData,
+    retry: (failureCount: number, error: Error) => {
       if (error instanceof Error && error.message.includes('4')) return false
       return failureCount < 3
     },
@@ -4284,13 +4353,13 @@ export function useBridgeInfiniteQuery<TData = unknown, TError = Error>(
     refetchOnWindowFocus: true,
     refetchOnReconnect: true,
     refetchOnMount: 'always',
-    placeholderData: (previousData) => previousData,
-    retry: (failureCount, error) => {
+    placeholderData: (previousData: TData | undefined) => previousData,
+    retry: (failureCount: number, error: Error) => {
       if (error instanceof Error && error.message.includes('4')) return false
       return failureCount < 3
     },
     ...options,
-  } as any)
+  })
 }
 
 /**
@@ -4307,7 +4376,7 @@ export function useBridgeSuspenseQuery<TData = unknown, TError = Error>(
     queryFn: queryFn as QueryFunction<TData, QueryKey>,
     staleTime: 5 * 60 * 1000,
     gcTime: 10 * 60 * 1000,
-    retry: (failureCount, error) => {
+    retry: (failureCount: number, error: Error) => {
       if (error instanceof Error && error.message.includes('4')) return false
       return failureCount < 3
     },
@@ -7522,9 +7591,6 @@ var UploadGenerator = class {
     const compressionFormats = uploads?.compression?.formats || ["gzip", "webp"];
     const content = `'use client'
 
-import { useMutation, useQueryClient } from '@tanstack/react-query'
-import { toast } from 'sonner'
-
 /**
  * Upload configuration
  */
@@ -7704,7 +7770,7 @@ export function createUploadFormData(
           "FileValidationResult",
           "UploadProgress"
         ],
-        imports: ["@tanstack/react-query", "sonner"],
+        imports: [],
         dependencies: []
       }
     };
@@ -7810,16 +7876,18 @@ async function uploadToS3(
     xhr.send(formData)
   })
 }
-
+` : "";
+    const needsBackendHelper = progressEnabled && useXHR || presignedEnabled && fallbackEnabled;
+    const backendUploadHelper = needsBackendHelper ? `
 /**
  * Upload via backend API with progress tracking
- * Uses generated server action for type-safe upload
+ * Uses XMLHttpRequest for progress tracking support
  */
 async function uploadViaBackendApi(
   formData: FormData,
   onProgress?: (progress: { loaded: number; total: number; percentage: number }) => void
 ): Promise<z.infer<typeof ${operationName}ResponseSchema>> {
-  ${progressEnabled && useXHR ? `return new Promise((resolve, reject) => {
+  return new Promise((resolve, reject) => {
     const xhr = new XMLHttpRequest()
 
     if (onProgress) {
@@ -7868,13 +7936,9 @@ async function uploadViaBackendApi(
       : '${this.configuration.api?.baseUrl || "http://localhost:8000"}'
     xhr.open('POST', \`\${baseUrl}${endpoint.path}\`)
     xhr.send(formData)
-  })` : `
-  // Use generated server action for type-safe upload (no progress tracking)
-  // Note: Server actions don't support progress tracking, use XHR for progress
-  const response = await ${actionName}(formData as any)
-  return response
-  `}
-}` : "";
+  })
+}
+` : "";
     const uploadLogic = presignedEnabled ? `
       let fileKey: string | null = null
       let directUploadAttempted = false
@@ -7989,6 +8053,7 @@ async function uploadViaBackendApi(
     `;
     const content = `${imports}
 ${presignedHelpers}
+${backendUploadHelper || ""}
 
 /**
  * Upload hook for ${endpoint.method} ${endpoint.path}
@@ -8025,7 +8090,7 @@ export function ${hookName}Upload(options?: {
 ${uploadLogic}
     },
     
-    onSuccess: (data) => {
+    onSuccess: (data: z.infer<typeof ${operationName}ResponseSchema>) => {
       // Don't show toast here, let the page handle it
       options?.onSuccess?.(data)
       
@@ -8239,7 +8304,9 @@ let toast: {
 } | null = null
 
 // Lazy load toast to avoid bundling issues
-async function getToast() {
+async function getToast(): Promise<{
+  error: (message: string, options?: { duration?: number; description?: string }) => void
+} | null> {
   if (toast !== null) return toast
   
   try {
@@ -8333,24 +8400,26 @@ export async function handleAuthError(error: unknown, redirectTo?: string): Prom
   const toastInstance = await getToast()
 
   // Show appropriate error message based on error type
-  if (isInactive) {
-    toastInstance.error('Your account has been deactivated. Please contact support for assistance.', {
-      duration: 5000,
-      description: 'You will be redirected to the login page.',
-    })
-  } else if (apiError.status === 401) {
-    toastInstance.error('Your session has expired. Please sign in again.', {
-      duration: 4000,
-    })
-  } else if (apiError.status === 403) {
-    toastInstance.error('Access denied. Your account may have been suspended.', {
-      duration: 5000,
-      description: 'You will be redirected to the login page.',
-    })
-  } else {
-    toastInstance.error('Authentication failed. Please sign in again.', {
-      duration: 4000,
-    })
+  if (toastInstance) {
+    if (isInactive) {
+      toastInstance.error('Your account has been deactivated. Please contact support for assistance.', {
+        duration: 5000,
+        description: 'You will be redirected to the login page.',
+      })
+    } else if (apiError.status === 401) {
+      toastInstance.error('Your session has expired. Please sign in again.', {
+        duration: 4000,
+      })
+    } else if (apiError.status === 403) {
+      toastInstance.error('Access denied. Your account may have been suspended.', {
+        duration: 5000,
+        description: 'You will be redirected to the login page.',
+      })
+    } else {
+      toastInstance.error('Authentication failed. Please sign in again.', {
+        duration: 4000,
+      })
+    }
   }
 
   if (typeof window !== 'undefined') {
@@ -8361,7 +8430,7 @@ export async function handleAuthError(error: unknown, redirectTo?: string): Prom
       const { signOut } = await import('${authPath}')
       signOut({
         redirect: false,
-      }).catch((signOutError) => {
+      }).catch((signOutError: unknown) => {
         console.error('[Auth Error Handler] Error during sign out (non-blocking):', signOutError)
       })
     } catch (importError) {
@@ -9350,7 +9419,8 @@ var bridgeConfigSchema = z.object({
     logging: z.boolean().default(true),
     validation: z.boolean().default(true),
     mocking: z.boolean().default(false),
-    watch: z.boolean().default(false)
+    watch: z.boolean().default(false),
+    hotReload: z.boolean().default(false)
   }).optional(),
   plugins: z.array(
     z.object({
@@ -9363,6 +9433,7 @@ var bridgeConfigSchema = z.object({
     typescript: z.boolean().default(true),
     strict: z.boolean().default(true),
     comments: z.boolean().default(true),
+    documentation: z.boolean().default(true),
     examples: z.boolean().default(false),
     tests: z.boolean().default(false)
   }).optional()
@@ -9468,12 +9539,14 @@ ${errorMessages}`,
         logging: true,
         validation: true,
         mocking: false,
-        watch: false
+        watch: false,
+        hotReload: false
       },
       generation: {
         typescript: true,
         strict: true,
         comments: true,
+        documentation: true,
         examples: false,
         tests: false
       }
@@ -9526,5 +9599,5 @@ ${errorMessages}`,
 };
 
 export { BridgeCore, BridgeError, BridgeLogger, ConfigurationLoader, FileSystemManager, GenerationError, LogLevel, NextJsCodeGenerator, OpenApiSchemaParser, SchemaParseError, ValidationError, VersionChecker, __name, checkAndNotifyUpdates, createBridgeVersionChecker };
-//# sourceMappingURL=chunk-IVMVPQUK.js.map
-//# sourceMappingURL=chunk-IVMVPQUK.js.map
+//# sourceMappingURL=chunk-7Y66DW7M.js.map
+//# sourceMappingURL=chunk-7Y66DW7M.js.map