mulink 1.1.7 → 1.1.9

package/dist/lib/{chunk-RGFU7SMN.cjs → chunk-NC747MZJ.cjs}

@@ -13,17 +13,48 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/core/types.ts
-var BridgeError = class extends Error {
+var BridgeError = class _BridgeError extends Error {
   static {
     __name(this, "BridgeError");
   }
   code;
   details;
-  constructor(message, code, details) {
-    super(message);
+  timestamp;
+  cause;
+  constructor(message, code, details, cause) {
+    super(message, { cause });
     this.name = "BridgeError";
     this.code = code;
     this.details = details;
+    this.timestamp = Date.now();
+    this.cause = cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _BridgeError);
+    }
+  }
+  /**
+   * Converts the error to a JSON-serializable object
+   * 
+   * @returns JSON representation of the error
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      details: this.details,
+      timestamp: this.timestamp,
+      stack: this.stack,
+      cause: this.cause?.message
+    };
+  }
+  /**
+   * Checks if this error is retryable
+   * 
+   * @returns True if the operation that caused this error can be retried
+   */
+  isRetryable() {
+    return false;
   }
 };
 var ValidationError = class extends BridgeError {
@@ -31,28 +62,42 @@ var ValidationError = class extends BridgeError {
     __name(this, "ValidationError");
   }
   errors;
-  constructor(message, errors) {
-    super(message, "VALIDATION_ERROR", errors);
+  constructor(message, errors, cause) {
+    super(message, "VALIDATION_ERROR", errors, cause);
     this.errors = errors;
   }
+  /**
+   * Gets formatted validation error messages
+   * 
+   * @returns Array of formatted error messages
+   */
+  getFormattedErrors() {
+    return this.errors.errors.map((err) => {
+      const path3 = err.path.join(".");
+      return `${path3}: ${err.message}`;
+    });
+  }
 };
 var SchemaParseError = class extends BridgeError {
   static {
     __name(this, "SchemaParseError");
   }
   schemaUrl;
-  constructor(message, schemaUrl) {
-    super(message, "SCHEMA_PARSE_ERROR", { schemaUrl });
+  constructor(message, schemaUrl, cause) {
+    super(message, "SCHEMA_PARSE_ERROR", { schemaUrl }, cause);
     this.schemaUrl = schemaUrl;
   }
+  isRetryable() {
+    return this.cause instanceof TypeError && this.cause.message.includes("fetch");
+  }
 };
 var GenerationError = class extends BridgeError {
   static {
     __name(this, "GenerationError");
   }
   file;
-  constructor(message, file) {
-    super(message, "GENERATION_ERROR", { file });
+  constructor(message, file, cause) {
+    super(message, "GENERATION_ERROR", { file }, cause);
     this.file = file;
   }
 };
@@ -140,8 +185,8 @@ var BridgeLogger = class {
     if (!this.options.colors || !process.stdout.isTTY) {
       console.log(message);
       return {
-        succeed: /* @__PURE__ */ __name((msg) => console.log(colorize(`\u2713 ${msg || message || ""}`, "green")), "succeed"),
-        fail: /* @__PURE__ */ __name((msg) => console.error(colorize(`\u2717 ${msg || message || ""}`, "red")), "fail"),
+        succeed: /* @__PURE__ */ __name((msg) => console.log(colorize(`\u2713 ${msg ?? message}`, "green")), "succeed"),
+        fail: /* @__PURE__ */ __name((msg) => console.error(colorize(`\u2717 ${msg ?? message}`, "red")), "fail"),
         stop: /* @__PURE__ */ __name(() => {
         }, "stop")
       };
@@ -149,17 +194,20 @@ var BridgeLogger = class {
     const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
     let i = 0;
     const interval = setInterval(() => {
-      process.stdout.write(`\r${colorize(frames[i++ % frames.length], "cyan")} ${message}`);
+      const frame = frames[i++ % frames.length];
+      if (frame) {
+        process.stdout.write(`\r${colorize(frame, "cyan")} ${message}`);
+      }
     }, 100);
     return {
       succeed: /* @__PURE__ */ __name((msg) => {
         clearInterval(interval);
-        process.stdout.write(`\r${colorize("\u2713", "green")} ${msg || message || ""}
+        process.stdout.write(`\r${colorize("\u2713", "green")} ${msg ?? message}
 `);
       }, "succeed"),
       fail: /* @__PURE__ */ __name((msg) => {
         clearInterval(interval);
-        process.stdout.write(`\r${colorize("\u2717", "red")} ${msg || message || ""}
+        process.stdout.write(`\r${colorize("\u2717", "red")} ${msg ?? message}
 `);
       }, "fail"),
       stop: /* @__PURE__ */ __name(() => {
@@ -182,7 +230,7 @@ var VersionChecker = class {
   constructor(packageName, currentVersion, logger) {
     this.packageName = packageName;
     this.currentVersion = currentVersion;
-    this.logger = logger || new BridgeLogger({ prefix: "\u{1F50D} Version Check" });
+    this.logger = logger ?? new BridgeLogger({ prefix: "\u{1F50D} Version Check" });
   }
   /**
    * Check if a new version is available
@@ -237,7 +285,7 @@ var VersionChecker = class {
   /**
    * Get the appropriate upgrade command for the detected package manager
    */
-  getUpgradeCommand(versionInfo) {
+  getUpgradeCommand(_versionInfo) {
     const packageManager = this.detectPackageManager();
     switch (packageManager) {
       case "yarn":
@@ -311,8 +359,8 @@ var VersionChecker = class {
       const currentParts = this.parseVersion(current);
       const latestParts = this.parseVersion(latest);
       for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
-        const currentPart = currentParts[i] || 0;
-        const latestPart = latestParts[i] || 0;
+        const currentPart = currentParts[i] ?? 0;
+        const latestPart = latestParts[i] ?? 0;
         if (latestPart > currentPart) {
           return true;
         } else if (latestPart < currentPart) {
@@ -386,7 +434,7 @@ function createBridgeVersionChecker(logger) {
     if (fs.existsSync(pkgPath)) {
       const pkgRaw = fs.readFileSync(pkgPath, { encoding: "utf-8" });
       const pkg = JSON.parse(pkgRaw);
-      if (pkg && pkg.version) {
+      if (pkg.version) {
         currentVersion = pkg.version;
       }
     } else {
@@ -394,13 +442,13 @@ function createBridgeVersionChecker(logger) {
       if (fs.existsSync(cwdPkg)) {
         const pkgRaw = fs.readFileSync(cwdPkg, { encoding: "utf-8" });
         const pkg = JSON.parse(pkgRaw);
-        if (pkg && pkg.version) {
+        if (pkg.version) {
           currentVersion = pkg.version;
         }
       }
     }
   } catch (err) {
-    const l = logger || new BridgeLogger({ prefix: "\u{1F50D} Version Check" });
+    const l = logger ?? new BridgeLogger({ prefix: "\u{1F50D} Version Check" });
     l.debug("Failed to read package.json for current version, falling back to default", err);
   }
   return new VersionChecker(packageName, currentVersion, logger);
@@ -438,7 +486,7 @@ var OpenApiSchemaParser = class {
   async fetchSchema(schemaUrl) {
     const versionChecker = createBridgeVersionChecker();
     const currentVersion = versionChecker.getCurrentVersion();
-    if (!schemaUrl?.trim()) {
+    if (!schemaUrl.trim()) {
       throw new SchemaParseError("Schema URL is required and cannot be empty", schemaUrl);
     }
     if (schemaUrl.startsWith("http")) {
@@ -459,7 +507,7 @@ var OpenApiSchemaParser = class {
             schemaUrl
           );
         }
-        const contentType = response.headers.get("content-type") || "";
+        const contentType = response.headers.get("content-type") ?? "";
         if (!contentType.includes("application/json") && !contentType.includes("application/yaml") && !contentType.includes("text/yaml")) {
           throw new SchemaParseError(
             `Unsupported content type: ${contentType}. Expected JSON or YAML.`,
@@ -489,10 +537,10 @@ var OpenApiSchemaParser = class {
       );
     }
   }
-  async parseDocument(document) {
+  parseDocument(document) {
     const version = this.detectVersion(document);
     const normalizedDocument = this.normalizeDocument(document, version);
-    return {
+    return Promise.resolve({
       version,
       document: normalizedDocument,
       openApiSpec: normalizedDocument,
@@ -501,7 +549,7 @@ var OpenApiSchemaParser = class {
       security: this.extractSecurity(normalizedDocument),
       servers: this.extractServers(normalizedDocument, document),
       metadata: this.extractMetadata(normalizedDocument)
-    };
+    });
   }
   detectVersion(document) {
     if (!document || typeof document !== "object") {
@@ -536,7 +584,7 @@ var OpenApiSchemaParser = class {
       info: v2Doc.info,
       servers: v2Doc.host ? [
         {
-          url: `${v2Doc.schemes?.[0] || "https"}://${v2Doc.host}${v2Doc.basePath || ""}`
+          url: `${v2Doc.schemes?.[0] ?? "https"}://${v2Doc.host}${v2Doc.basePath ?? ""}`
         }
       ] : [],
       paths: {},
@@ -681,20 +729,20 @@ var OpenApiSchemaParser = class {
               flows: {
                 implicit: v2Scheme.flow === "implicit" ? {
                   authorizationUrl: v2Scheme.authorizationUrl,
-                  scopes: v2Scheme.scopes || {}
+                  scopes: v2Scheme.scopes ?? {}
                 } : void 0,
                 password: v2Scheme.flow === "password" ? {
                   tokenUrl: v2Scheme.tokenUrl,
-                  scopes: v2Scheme.scopes || {}
+                  scopes: v2Scheme.scopes ?? {}
                 } : void 0,
                 clientCredentials: v2Scheme.flow === "application" ? {
                   tokenUrl: v2Scheme.tokenUrl,
-                  scopes: v2Scheme.scopes || {}
+                  scopes: v2Scheme.scopes ?? {}
                 } : void 0,
                 authorizationCode: v2Scheme.flow === "accessCode" ? {
                   authorizationUrl: v2Scheme.authorizationUrl,
                   tokenUrl: v2Scheme.tokenUrl,
-                  scopes: v2Scheme.scopes || {}
+                  scopes: v2Scheme.scopes ?? {}
                 } : void 0
               }
             };
@@ -720,18 +768,18 @@ var OpenApiSchemaParser = class {
         const operation = pathItem[method.toLowerCase()];
         if (!operation) continue;
         const endpoint = {
-          id: operation.operationId || `${method.toLowerCase()}_${path3.replace(/[^a-zA-Z0-9]/g, "_")}`,
+          id: operation.operationId ?? `${method.toLowerCase()}_${path3.replace(/[^a-zA-Z0-9]/g, "_")}`,
           path: path3,
           method,
           operationId: operation.operationId,
           summary: operation.summary,
           description: operation.description,
-          tags: operation.tags || [],
+          tags: operation.tags ?? [],
           parameters: this.extractParameters(operation.parameters, pathItem.parameters, document),
           requestBody: this.extractRequestBody(operation.requestBody, document),
           responses: this.extractResponses(operation.responses, document),
-          security: operation.security || [],
-          deprecated: operation.deprecated || false,
+          security: operation.security ?? [],
+          deprecated: operation.deprecated ?? false,
           metadata: this.extractEndpointMetadata(operation)
         };
         endpoints.push(endpoint);
@@ -741,7 +789,7 @@ var OpenApiSchemaParser = class {
   }
   extractParameters(operationParams, pathParams, document) {
     const parameters = [];
-    const allParams = [...pathParams || [], ...operationParams || []];
+    const allParams = [...pathParams ?? [], ...operationParams ?? []];
     for (const param of allParams) {
       if (!param) continue;
       if ("$ref" in param) {
@@ -751,11 +799,11 @@ var OpenApiSchemaParser = class {
       const parameter = {
         name: param.name,
         in: param.in,
-        required: param.required || param.in === "path",
+        required: param.required ?? param.in === "path",
         schema: this.convertSchemaToZod(param.schema, document),
         description: param.description,
         example: param.example,
-        deprecated: param.deprecated || false
+        deprecated: param.deprecated ?? false
       };
       parameters.push(parameter);
     }
@@ -774,7 +822,7 @@ var OpenApiSchemaParser = class {
       }
     }
     return {
-      required: requestBody.required || false,
+      required: requestBody.required ?? false,
       description: requestBody.description,
       content
     };
@@ -814,7 +862,7 @@ var OpenApiSchemaParser = class {
           schema: this.convertSchemaToZod(schema, document),
           description: schema.description,
           example: schema.example,
-          deprecated: schema.deprecated || false
+          deprecated: schema.deprecated ?? false
         });
       }
     }
@@ -848,7 +896,7 @@ var OpenApiSchemaParser = class {
       const v2Doc = originalDoc;
       return [
         {
-          url: `${v2Doc.schemes?.[0] || "https"}://${v2Doc.host}${v2Doc.basePath || ""}`,
+          url: `${v2Doc.schemes?.[0] ?? "https"}://${v2Doc.host}${v2Doc.basePath ?? ""}`,
           description: "Converted from Swagger 2.0"
         }
       ];
@@ -868,9 +916,9 @@ var OpenApiSchemaParser = class {
   }
   extractEndpointMetadata(operation) {
     return {
-      requiresAuth: operation.security && operation.security.length > 0 || false,
+      requiresAuth: (operation.security?.length ?? 0) > 0,
       cacheStrategy: "default",
-      revalidationTags: operation.tags || [],
+      revalidationTags: operation.tags ?? [],
       streaming: false,
       fileUpload: this.hasFileUpload(operation)
     };
@@ -878,7 +926,7 @@ var OpenApiSchemaParser = class {
   hasFileUpload(operation) {
     if (!operation.requestBody || "$ref" in operation.requestBody) return false;
     const content = operation.requestBody.content;
-    return Object.keys(content || {}).some(
+    return Object.keys(content ?? {}).some(
       (mediaType) => mediaType.includes("multipart/form-data") || mediaType.includes("application/octet-stream")
     );
   }
@@ -966,7 +1014,7 @@ var OpenApiSchemaParser = class {
       case "object":
         if (schema.properties) {
           const shape = {};
-          const required = schema.required || [];
+          const required = schema.required ?? [];
           for (const [propName, propSchema] of Object.entries(schema.properties)) {
             let propZodSchema = this.convertSchemaToZod(propSchema, document);
             if (!required.includes(propName)) {
@@ -998,7 +1046,7 @@ var ApiClientGenerator = class {
    * Generate import paths based on configuration
    */
   buildImportPath(relativePath) {
-    const outputDirectory = this.configuration.outputDir || "generated";
+    const outputDirectory = this.configuration.outputDir ?? "generated";
     const cleanPath = relativePath.startsWith("/") ? relativePath.slice(1) : relativePath;
     let importBasePath = outputDirectory;
     if (importBasePath.startsWith("src/")) {
@@ -1006,24 +1054,24 @@ var ApiClientGenerator = class {
     }
     return `@/${importBasePath}/${cleanPath}`;
   }
-  async generate(context) {
+  generate(context) {
     const { schema } = context;
     const generatedFiles = [];
     generatedFiles.push(this.generateEnhancedBaseClient());
     generatedFiles.push(...this.generateEndpointClients(schema.endpoints));
     generatedFiles.push(this.generateMainClient(schema.endpoints));
     generatedFiles.push(this.generateClientUtilities());
-    return generatedFiles;
+    return Promise.resolve(generatedFiles);
   }
   generateEnhancedBaseClient() {
     const { api, auth } = this.configuration;
     const authUtilsImport = this.buildImportPath("auth/utils");
-    const authPath = auth?.authPath || "@/lib/auth";
-    const tokenGetter = auth?.tokenGetter || "auth";
+    const authPath = auth?.authPath ?? "@/lib/auth";
+    const tokenGetter = auth?.tokenGetter ?? "auth";
     const content = `/**
  * The HTTP client is automatically created by "mulink"
  * 
- * Next.js 16.0.1 Best Practices:
+ * Next.js 16.0.7 Best Practices:
  * - Proper separation of client/server code
  * - Dynamic imports for server-only modules
  * - Works in both Server Components and Client Components
@@ -1034,7 +1082,7 @@ import { cache } from 'react'
 
 /**
  * Server-only modules interface
- * Next.js 16.0.1: These modules are only available on the server
+ * Next.js 16.0.7: These modules are only available on the server
  * We use dynamic imports to avoid bundling them in the client
  */
 type NextHeadersModule = typeof import('next/headers')
@@ -1058,7 +1106,7 @@ function toMutableHeaders(source: NextReadonlyHeaders) {
 
 /**
  * Lazy load server-only modules only when needed (server-side)
- * Next.js 16.0.1: This ensures server-only code is not bundled in the client
+ * Next.js 16.0.7: This ensures server-only code is not bundled in the client
  * 
  * @returns Server-only modules or undefined if on client-side
  */
@@ -1066,7 +1114,7 @@ async function getServerModules() {
   if (serverOnlyModules !== null) return serverOnlyModules
   
   // Only attempt to import on server-side
-  // Next.js 16.0.1: typeof window check ensures we're on the server
+  // Next.js 16.0.7: typeof window check ensures we're on the server
   if (typeof window === 'undefined') {
     try {
       const headersModule = await import('next/headers').catch(() => null)
@@ -1292,11 +1340,11 @@ export class BaseApiClient {
   private readonly middleware: RequestMiddleware[] = []
 
   constructor() {
-    this.baseUrl = process.env.NEXT_PUBLIC_API_URL || process.env.API_BASE_URL || '${api?.baseUrl || "http://localhost:3000/api"}'
-    this.defaultTimeout = ${api?.timeout || 3e4}
-    this.defaultRetries = ${api?.retries || 3}
-    this.defaultHeaders = ${JSON.stringify(api?.headers || {}, null, 6)}
-    this.defaultUserAgent = '${api?.userAgent || "Mulink-Client/3.4.5"}'
+    this.baseUrl = process.env.NEXT_PUBLIC_API_URL || process.env.API_BASE_URL || '${api.baseUrl || "http://localhost:3000/api"}'
+    this.defaultTimeout = ${api.timeout || 3e4}
+    this.defaultRetries = ${api.retries || 3}
+    this.defaultHeaders = ${JSON.stringify(api.headers || {}, null, 6)}
+    this.defaultUserAgent = '${api.userAgent || "Mulink-Client/3.4.5"}'
     
     // Add default middleware
     this.addMiddleware({
@@ -1470,16 +1518,26 @@ export class BaseApiClient {
     }
     
     // Add query parameters with proper encoding
+    // Filter out undefined, null, empty strings, and empty objects to prevent 422 errors
     const searchParams = new URLSearchParams()
     for (const [key, value] of Object.entries(queryParameters)) {
-      if (value !== undefined && value !== null && value !== '') {
-        if (Array.isArray(value)) {
-          value.forEach(v => searchParams.append(key, String(v)))
-        } else if (typeof value === 'object') {
-          searchParams.append(key, JSON.stringify(value))
-        } else {
-          searchParams.append(key, String(value))
-        }
+      // Skip undefined, null, and empty strings
+      if (value === undefined || value === null || value === '') {
+        continue
+      }
+      
+      // Skip empty objects (like {})
+      if (typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 0) {
+        continue
+      }
+      
+      if (Array.isArray(value)) {
+        value.forEach(v => searchParams.append(key, String(v)))
+      } else if (typeof value === 'object') {
+        // Only serialize non-empty objects
+        searchParams.append(key, JSON.stringify(value))
+      } else {
+        searchParams.append(key, String(value))
       }
     }
     
@@ -1652,7 +1710,7 @@ export class BaseApiClient {
           controller.abort()
         }, timeout)
         
-        // Next.js 16.0.1: Build fetch options with cache tags and connection
+        // Next.js 16.0.7: Build fetch options with cache tags and connection
         // Only include next options if we're on the server (Next.js App Router)
         const fetchInit: RequestInit & { next?: { tags?: string[]; revalidate?: number | false; connection?: string } } = {
           ...requestConfig,
@@ -1660,7 +1718,7 @@ export class BaseApiClient {
         }
         
         // Add Next.js-specific options only if we have cache tags, revalidate, or connection
-        // Next.js 16.0.1: Enhanced cache tag support with updateTag
+        // Next.js 16.0.7: Enhanced cache tag support with updateTag
         if (cacheTags && cacheTags.length > 0 || revalidate !== undefined || connection) {
           fetchInit.next = {}
           
@@ -1672,7 +1730,7 @@ export class BaseApiClient {
             fetchInit.next.revalidate = revalidate === false ? false : revalidate
           }
           
-          // Next.js 16.0.1: Connection keep-alive for persistent connections
+          // Next.js 16.0.7: Connection keep-alive for persistent connections
           if (connection) {
             fetchInit.next.connection = connection
           }
@@ -1680,7 +1738,7 @@ export class BaseApiClient {
         
         const response = await fetch(url, fetchInit)
         
-        // Next.js 16.0.1: Update cache tags dynamically using updateTag from next/cache
+        // Next.js 16.0.7: Update cache tags dynamically using updateTag from next/cache
         // This allows for granular cache invalidation
         if (cacheTags && cacheTags.length > 0) {
           try {
@@ -1944,7 +2002,7 @@ async get<TData>(
   }
   generateClientUtilities() {
     const { api } = this.configuration;
-    const errorHandling = api?.errorHandling;
+    const errorHandling = api.errorHandling;
     const enableAuthErrorHandling = errorHandling?.enableAuthErrorHandling !== false;
     const authErrorHandlerPath = errorHandling?.authErrorHandlerPath || "@/lib/auth-error-handler";
     const authErrorMiddlewareCode = enableAuthErrorHandling ? `
@@ -2341,7 +2399,7 @@ ${clientMethods}
     const requestOptionsString = requestOptions.join("\n");
     const methodSignature = parameterTypes.length > 1 ? `options: {
     ${parameterTypes.join("\n    ")}
-  }` : parameterTypes.length === 1 && parameterTypes[0].includes("config?") ? "options?: { config?: RequestConfiguration }" : `options: { ${parameterTypes.join(", ")} }`;
+  }` : parameterTypes.length === 1 && parameterTypes[0] && parameterTypes[0].includes("config?") ? "options?: { config?: RequestConfiguration }" : `options: { ${parameterTypes.join(", ")} }`;
     if (isQuery) {
       return `${documentation}
   ${methodName} = cache(async (${methodSignature}) => {
@@ -2612,7 +2670,7 @@ var SchemaGenerator = class {
       visiting.add(schemaName);
       const schema = schemaMap.get(schemaName);
       if (schema) {
-        const dependencies = dependencyGraph.get(schemaName) || /* @__PURE__ */ new Set();
+        const dependencies = dependencyGraph.get(schemaName) ?? /* @__PURE__ */ new Set();
         for (const dep of dependencies) {
           if (schemaMap.has(dep)) {
             visit(dep);
@@ -2645,13 +2703,13 @@ var SchemaGenerator = class {
   findSchemaDependencies(schema) {
     const dependencies = [];
     const schemaObj = schema.schema;
-    if (schemaObj && schemaObj._def) {
+    if (schemaObj?._def) {
       this.extractDependenciesFromZodSchema(schemaObj, dependencies);
     }
     return dependencies;
   }
   extractDependenciesFromZodSchema(zodSchema, dependencies, visited = /* @__PURE__ */ new Set()) {
-    if (!zodSchema || !zodSchema._def) return;
+    if (!zodSchema?._def) return;
     const def = zodSchema._def;
     if (def._schemaRef) {
       const refName = def._schemaRef;
@@ -2674,7 +2732,7 @@ var SchemaGenerator = class {
       case "ZodObject":
         if (def.shape) {
           const shape = def.shape();
-          for (const [key, value] of Object.entries(shape)) {
+          for (const [_key, value] of Object.entries(shape)) {
             this.extractDependenciesFromZodSchema(value, dependencies, visited);
           }
         }
@@ -2706,7 +2764,7 @@ var SchemaGenerator = class {
         break;
     }
   }
-  async generateSchemasFile(context) {
+  generateSchemasFile(context) {
     const { schemas, endpoints } = context.schema;
     const imports = ['import { z } from "zod"'];
     const schemaExports = [];
@@ -2740,7 +2798,7 @@ var SchemaGenerator = class {
 
 ${content}`;
     }
-    return {
+    return Promise.resolve({
       path: "schemas/index.ts",
       content,
       type: "typescript",
@@ -2749,7 +2807,7 @@ ${content}`;
         imports: ["zod"],
         dependencies: []
       }
-    };
+    });
   }
   generateEndpointSchemas(endpoint) {
     const definitions = [];
@@ -2784,6 +2842,9 @@ ${content}`;
     }
     const exportName = `${operationName}RequestSchema`;
     const primaryContent = endpoint.requestBody.content[0];
+    if (!primaryContent) {
+      throw new Error(`No content found for request body in ${endpoint.method} ${endpoint.path}`);
+    }
     const zodSchemaString = this.zodSchemaToString(primaryContent.schema);
     const definition = [
       `/**`,
@@ -2807,17 +2868,22 @@ ${content}`;
     );
     if (successResponses.length > 0) {
       const successResponse = successResponses[0];
+      if (!successResponse) {
+        return { definitions, exports };
+      }
       let zodSchemaString = "z.void()";
       if (successResponse.content && successResponse.content.length > 0) {
         const primaryContent = successResponse.content[0];
-        zodSchemaString = this.zodSchemaToString(primaryContent.schema);
+        if (primaryContent) {
+          zodSchemaString = this.zodSchemaToString(primaryContent.schema);
+        }
       }
       const exportName = `${operationName}ResponseSchema`;
       const definition = [
         `/**`,
         ` * Success response schema for ${endpoint.method} ${endpoint.path}`,
         ` * Status: ${successResponse.statusCode}`,
-        ` * ${successResponse.description}`,
+        ` * ${successResponse.description ?? ""}`,
         ` */`,
         `export const ${exportName} = ${zodSchemaString}`,
         "",
@@ -2828,15 +2894,18 @@ ${content}`;
     }
     if (errorResponses.length > 0) {
       const errorResponse = errorResponses[0];
-      if (errorResponse.content && errorResponse.content.length > 0) {
+      if (errorResponse?.content && errorResponse.content.length > 0) {
         const exportName = `${operationName}ErrorSchema`;
         const primaryContent = errorResponse.content[0];
+        if (!primaryContent) {
+          return { definitions, exports };
+        }
         const zodSchemaString = this.zodSchemaToString(primaryContent.schema);
         const definition = [
           `/**`,
           ` * Error response schema for ${endpoint.method} ${endpoint.path}`,
           ` * Status: ${errorResponse.statusCode}`,
-          ` * ${errorResponse.description}`,
+          ` * ${errorResponse.description ?? ""}`,
           ` */`,
           `export const ${exportName} = ${zodSchemaString}`,
           "",
@@ -2927,8 +2996,8 @@ ${schemaProperties.join(",\n")}
     };
   }
   zodSchemaToString(schema, context) {
-    if (!schema || !schema._def) {
-      if (schema && schema._schemaRef) {
+    if (!schema?._def) {
+      if (schema?._schemaRef) {
         const refName = schema._schemaRef;
         const registeredSchema = this.schemaRegistry.get(refName);
         if (registeredSchema) {
@@ -3096,15 +3165,21 @@ export const errorMessages = {
       const assignments = line.match(/(\w+)\s*[:=]/g);
       if (assignments) {
         assignments.forEach((match) => {
-          const identifier = match.split(/[:=]/)[0].trim();
-          usedIdentifiers.add(identifier);
+          const parts = match.split(/[:=]/);
+          if (parts[0]) {
+            const identifier = parts[0].trim();
+            usedIdentifiers.add(identifier);
+          }
         });
       }
       const functionCalls = line.match(/(\w+)\s*\(/g);
       if (functionCalls) {
         functionCalls.forEach((match) => {
-          const identifier = match.split("(")[0].trim();
-          usedIdentifiers.add(identifier);
+          const parts = match.split("(");
+          if (parts[0]) {
+            const identifier = parts[0].trim();
+            usedIdentifiers.add(identifier);
+          }
         });
       }
       if (line.includes("z.infer")) {
@@ -3122,10 +3197,10 @@ export const errorMessages = {
           continue;
         }
         const importMatch = line.match(/import\s*\{([^}]+)\}/);
-        if (importMatch) {
+        if (importMatch?.[1]) {
           const imports = importMatch[1].split(",").map((imp) => imp.trim());
           const usedImports = imports.filter((imp) => usedIdentifiers.has(imp));
-          if (usedImports.length > 0) {
+          if (usedImports.length > 0 && importMatch[1]) {
             cleanedLines.push(line.replace(importMatch[1], usedImports.join(", ")));
           } else {
             continue;
@@ -3172,7 +3247,7 @@ var ActionGenerator = class {
     if (!this.documentationEnabled) {
       return "";
     }
-    const summary = endpoint.summary || endpoint.description || `${endpoint.method} ${endpoint.path}`;
+    const summary = endpoint.summary ?? endpoint.description ?? `${endpoint.method} ${endpoint.path}`;
     return `/**
  * ${summary}
  * @generated from ${endpoint.method} ${endpoint.path}
@@ -3314,7 +3389,7 @@ ${" ".repeat(indent + 2)}error: error instanceof Error ? error.message : 'Unknow
 ${" ".repeat(indent)}})`;
   }
   buildImportPath(relativePath) {
-    const outputDirectory = this.configuration.outputDir || "generated";
+    const outputDirectory = this.configuration.outputDir ?? "generated";
     const cleanPath = relativePath.startsWith("/") ? relativePath.slice(1) : relativePath;
     let importBasePath = outputDirectory;
     if (importBasePath.startsWith("src/")) {
@@ -3322,7 +3397,7 @@ ${" ".repeat(indent)}})`;
     }
     return `@/${importBasePath}/${cleanPath}`;
   }
-  async generate(context) {
+  generate(context) {
     const { schema, config } = context;
     const generatedFiles = [];
     const endpointsByTag = this.groupEndpointsByTag(schema.endpoints);
@@ -3416,7 +3491,7 @@ ${actions}`;
         dependencies: Object.keys(endpointsByTag).map((tag) => `./${toValidIdentifier(tag)}`)
       }
     });
-    return generatedFiles;
+    return Promise.resolve(generatedFiles);
   }
   getOperationName(endpoint) {
     if (endpoint.operationId) {
@@ -3429,7 +3504,7 @@ ${actions}`;
     const method = this.toPascalCase(endpoint.method.toLowerCase());
     return [...pathParts, method].join("");
   }
-  generateOptimizedServerAction(endpoint, config) {
+  generateOptimizedServerAction(endpoint, _config) {
     const actionName = toActionName(endpoint.operationId || endpoint.id);
     const operationName = this.getOperationName(endpoint);
     const hasRequestBody = !!endpoint.requestBody;
@@ -3470,10 +3545,15 @@ ${actions}`;
       parameterProcessing = "";
       requestOptionsParams = "";
     }
-    const parsedInputType = hasRequestBody || hasAnyParams ? schemaName.includes("\n") ? `z.infer<typeof z.object({ body: ${operationName}RequestSchema, params: ${operationName}ParamsSchema })>` : `z.infer<typeof ${schemaName}>` : "void";
+    const schemaConstantName = hasRequestBody && hasAnyParams ? `${operationName}InputSchema` : null;
+    const schemaConstantDefinition = schemaConstantName ? `const ${schemaConstantName} = z.object({ body: ${operationName}RequestSchema, params: ${operationName}ParamsSchema })
+
+` : "";
+    const parsedInputType = hasRequestBody || hasAnyParams ? schemaConstantName ? `z.infer<typeof ${schemaConstantName}>` : `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 = schemaName.includes("\n") ? `{ parsedInput: z.infer<typeof z.object({ body: ${operationName}RequestSchema, params: ${operationName}ParamsSchema })>; ${ctxDeclaration} }` : `{ parsedInput: ${parsedInputType}; ${ctxDeclaration} }`;
+    const actionArgsType = schemaConstantName ? `{ parsedInput: z.infer<typeof ${schemaConstantName}>; ${ctxDeclaration} }` : `{ parsedInput: ${parsedInputType}; ${ctxDeclaration} }`;
+    const actionArgsTypeForTemplate = actionArgsType.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
     const clientName = requiresAuth || hasRateLimit ? "authActionClient" : "actionClientWithMeta";
     const rateLimitCode = hasRateLimit ? `
 ${this.commentLine("Rate limiting", 6)}      const { userAgent, ip } = await getClientInfo()
@@ -3496,15 +3576,15 @@ ${this.commentLine("Rate limiting", 6)}      const { userAgent, ip } = await get
         endpoint,
         "React cache, input validation, error handling"
       );
-      return `${docBlock}export const ${actionName} = cache(
+      return `${docBlock}${schemaConstantDefinition}export const ${actionName} = cache(
   ${clientName}
     .metadata({
       name: "${kebabActionName}",
       requiresAuth: ${requiresAuth}${hasRateLimit ? `,
       rateLimit: { requests: ${endpoint.metadata.rateLimit?.requests || 10}, window: "${endpoint.metadata.rateLimit?.window || "1m"}" }` : ""}
     })
-    .schema(${schemaName.includes("\n") ? `z.object({ body: ${operationName}RequestSchema, params: ${operationName}ParamsSchema })` : schemaName})
-    .action(async ({ parsedInput, ctx }: ${actionArgsType}) => {
+    .schema(${schemaConstantName || schemaName})
+    .action(async ({ parsedInput, ctx }: ${actionArgsTypeForTemplate}) => {
       const startTime = Date.now()
       
       try {${rateLimitCode}${parameterProcessing}
@@ -3563,14 +3643,14 @@ ${this.commentLine("Process file with compression and validation if enabled", 10
       endpoint,
       "Input validation, revalidation, error handling"
     );
-    return `${mutationDocBlock}export const ${actionName} = ${clientName}
+    return `${mutationDocBlock}${schemaConstantDefinition}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.includes("\n") ? `z.object({ body: ${operationName}RequestSchema, params: ${operationName}ParamsSchema })` : schemaName})
-  .action(async ({ parsedInput, ctx }: ${actionArgsType}) => {
+  .schema(${schemaConstantName || schemaName})
+  .action(async ({ parsedInput, ctx }: ${actionArgsTypeForTemplate}) => {
     const startTime = Date.now()
     
     try {${rateLimitCode}${parameterProcessing}${fileUploadCode}
@@ -3698,7 +3778,7 @@ var HookGenerator = class {
     __name(this, "HookGenerator");
   }
   buildImportPath(relativePath) {
-    const outputDirectory = this.configuration.outputDir || "generated";
+    const outputDirectory = this.configuration.outputDir ?? "generated";
     const cleanPath = relativePath.startsWith("/") ? relativePath.slice(1) : relativePath;
     let importBasePath = outputDirectory;
     if (importBasePath.startsWith("src/")) {
@@ -3706,7 +3786,7 @@ var HookGenerator = class {
     }
     return `@/${importBasePath}/${cleanPath}`;
   }
-  async generate(context) {
+  generate(context) {
     const { schema } = context;
     const generatedFiles = [];
     const endpointsByTag = this.groupEndpointsByTag(schema.endpoints);
@@ -3839,7 +3919,7 @@ ${Object.keys(endpointsByTag).map((tag) => `export * from './${toValidIdentifier
         dependencies: ["./useBridgeQuery", ...Object.keys(endpointsByTag).map((tag) => `./${toValidIdentifier(tag)}`)]
       }
     });
-    return generatedFiles;
+    return Promise.resolve(generatedFiles);
   }
   getOperationName(endpoint) {
     if (endpoint.operationId) {
@@ -3856,44 +3936,65 @@ ${Object.keys(endpointsByTag).map((tag) => `export * from './${toValidIdentifier
     const hookName = toHookName(endpoint.operationId || endpoint.id, true);
     const actionName = toActionName(endpoint.operationId || endpoint.id);
     const operationName = this.getOperationName(endpoint);
-    const queryKey = this.generateQueryKey(endpoint);
     const staleTime = this.getStaleTime(endpoint);
     const pathParameters = endpoint.parameters.filter((parameter) => parameter.in === "path");
     const queryParameters = endpoint.parameters.filter((parameter) => parameter.in === "query");
     const hasPageParam = queryParameters.some((param) => param.name === "page");
     const hasSearchParams = endpoint.path.includes("search") || endpoint.path.includes("list");
-    endpoint.parameters.length > 0;
-    const parameterTypes = [];
+    const pathParamTypes = [];
+    const queryParamTypes = [];
     pathParameters.forEach((param) => {
       const isRequired = param.required ? "" : "?";
       const paramType = this.getTypeFromZodSchema(param.schema);
-      parameterTypes.push(`${param.name}${isRequired}: ${paramType}`);
+      pathParamTypes.push(`${param.name}${isRequired}: ${paramType}`);
     });
     queryParameters.forEach((param) => {
       const isRequired = param.required ? "" : "?";
       const paramType = this.getTypeFromZodSchema(param.schema);
-      parameterTypes.push(`${param.name}${isRequired}: ${paramType}`);
+      queryParamTypes.push(`${param.name}${isRequired}: ${paramType}`);
     });
     const returnType = `z.infer<typeof ${operationName}ResponseSchema>`;
     const optionsType = `{ enabled?: boolean; suspense?: boolean; refetchInterval?: number; initialData?: ${returnType} }`;
-    const enabledCondition = pathParameters.length > 0 ? `!!${pathParameters.map((parameter) => parameter.name).join(" && !!")}` : "true";
-    const actionCallParams = this.buildActionCallParams(endpoint, false);
+    const paramsTypeParts = [];
+    if (pathParameters.length > 0) {
+      paramsTypeParts.push(`path: { ${pathParamTypes.join("; ")} }`);
+    }
+    if (queryParameters.length > 0) {
+      paramsTypeParts.push(`query?: { ${queryParamTypes.join("; ")} }`);
+    }
+    const paramsType = paramsTypeParts.length > 0 ? `{ ${paramsTypeParts.join("; ")} }` : "{}";
+    const enabledCondition = pathParameters.length > 0 && pathParameters[0] ? `!!params?.path?.${pathParameters[0].name}` : "true";
+    const pathParamsBuild = pathParameters.length > 0 ? `{ ${pathParameters.map((p) => `${p.name}: params.path.${p.name}`).join(", ")} }` : "{}";
+    const queryParamsBuild = queryParameters.length > 0 ? `{ ${queryParameters.map((p) => `${p.name}: params?.query?.${p.name}`).join(", ")} }` : "{}";
     if (hasSearchParams) {
-      const queryParamObject = queryParameters.length > 0 ? `{ ${queryParameters.map((param) => `${param.name}`).join(", ")} }` : "{}";
+      const queryParamsWithFallback = queryParameters.length > 0 ? `const queryParams = {
+          ${queryParameters.map((param) => {
+        if (param.name === "query") {
+          return `${param.name}: params?.query?.${param.name} || searchParams.search || ''`;
+        } else if (param.name === "limit") {
+          return `${param.name}: params?.query?.${param.name} !== undefined ? params.query.${param.name} : searchParams.limit`;
+        } else {
+          return `${param.name}: params?.query?.${param.name}`;
+        }
+      }).join(",\n          ")}
+        }` : "const queryParams = {}";
       return `/**
  * Optimized query hook for ${endpoint.method} ${endpoint.path}
  * Features: URL state sync, infinite loading, optimistic updates
+ * @param params - Named parameters object with path and query parameters
+ * @param options - Query options
  * @returns useQuery result with data of type ${returnType}
  */
-export function ${hookName}(${parameterTypes.length > 0 ? `${parameterTypes.join(", ")}, ` : ""}options?: ${optionsType}) {
+export function ${hookName}(params${pathParameters.length > 0 ? "" : "?"}: ${paramsType}, options?: ${optionsType}) {
   const [searchParams] = useQueryStates(searchParamsParser)
   const { initialData, ...restOptions } = options ?? {}
   
   return useQuery({
-    queryKey: [...${queryKey}, searchParams],
+    queryKey: ['${toActionName(endpoint.operationId || endpoint.id)}', ${pathParameters.length > 0 ? "params?.path" : "null"}, params?.query, searchParams],
     queryFn: async ({ signal }: { signal?: AbortSignal }) => {
       try {
-        const result = await resolveActionResult<${returnType}>(${actionName}(${actionCallParams.replace(queryParamObject, "{ ...searchParams }")}))
+        ${queryParamsWithFallback}
+        const result = await resolveActionResult<${returnType}>(${actionName}(${pathParameters.length > 0 ? `{ path: ${pathParamsBuild}, query: queryParams }` : "{ query: queryParams }"}))
         return result
       } catch (error) {
         handleActionError(error)
@@ -3921,29 +4022,33 @@ export function ${hookName}(${parameterTypes.length > 0 ? `${parameterTypes.join
 
 /**
  * Infinite query version for paginated ${endpoint.path}
+ * @param params - Named parameters object with path and query parameters
+ * @param options - Query options
  * @returns useInfiniteQuery result with data of type ${returnType}
  */
-export function ${hookName.replace("use", "useInfinite")}(${parameterTypes.length > 0 ? `${parameterTypes.join(", ")}, ` : ""}options?: ${optionsType}) {
+export function ${hookName.replace("use", "useInfinite")}(params${pathParameters.length > 0 ? "" : "?"}: ${paramsType}, options?: ${optionsType}) {
   const [searchParams] = useQueryStates(searchParamsParser)
   const { initialData, ...restOptions } = options ?? {}
 
   return useInfiniteQuery({
-    queryKey: [...${queryKey}, 'infinite', searchParams],
+    queryKey: ['${toActionName(endpoint.operationId || endpoint.id)}', ${pathParameters.length > 0 ? "params?.path" : "null"}, params?.query, 'infinite', searchParams],
     initialPageParam: 1,
     queryFn: async ({ pageParam = 1, signal }: { pageParam?: number; signal?: AbortSignal }) => {
       try {
-        // Build query params object with only the parameters the endpoint expects
-        const queryParams: Record<string, any> = {}
-        ${queryParameters.map((param) => {
+        const queryParams = {
+          ${queryParameters.map((param) => {
         if (param.name === "page" && hasPageParam) {
-          return `queryParams.${param.name} = pageParam`;
+          return `${param.name}: pageParam`;
+        } else if (param.name === "query") {
+          return `${param.name}: params?.query?.${param.name} || searchParams.search || ''`;
         } else if (param.name === "limit") {
-          return `queryParams.${param.name} = searchParams.limit`;
+          return `${param.name}: params?.query?.${param.name} !== undefined ? params.query.${param.name} : searchParams.limit`;
         } else {
-          return `if ('${param.name}' in searchParams) queryParams.${param.name} = searchParams.${param.name}`;
+          return `${param.name}: params?.query?.${param.name}`;
+        }
+      }).join(",\n          ")}
         }
-      }).join("\n        ")}
-        const result = await resolveActionResult<${returnType}>(${actionName}(${actionCallParams.replace(queryParamObject, "queryParams")}))
+        const result = await resolveActionResult<${returnType}>(${actionName}(${pathParameters.length > 0 ? `{ path: ${pathParamsBuild}, query: queryParams }` : "{ query: queryParams }"}))
         return result
       } catch (error) {
         handleActionError(error)
@@ -3985,15 +4090,17 @@ export function ${hookName.replace("use", "useInfinite")}(${parameterTypes.lengt
 
 /**
  * Suspense version for ${endpoint.path} - use in Server Components
+ * @param params - Named parameters object with path and query parameters
+ * @param options - Query options
  * @returns useSuspenseQuery result with data of type ${returnType}
  */
-export function ${hookName.replace("use", "useSuspense")}(${parameterTypes.length > 0 ? `${parameterTypes.join(", ")}, ` : ""}options?: ${optionsType}) {
+export function ${hookName.replace("use", "useSuspense")}(params${pathParameters.length > 0 ? "" : "?"}: ${paramsType}, options?: ${optionsType}) {
   const { initialData, ...restOptions } = options ?? {}
 
   return useSuspenseQuery({
-    queryKey: ${queryKey},
+    queryKey: ['${toActionName(endpoint.operationId || endpoint.id)}', ${pathParameters.length > 0 ? "params?.path" : "null"}, params?.query],
     queryFn: async () => {
-      const result = await resolveActionResult<${returnType}>(${actionName}(${actionCallParams}))
+      const result = await resolveActionResult<${returnType}>(${actionName}(${pathParameters.length > 0 ? `{ path: ${pathParamsBuild}, query: ${queryParamsBuild} }` : `{ query: ${queryParamsBuild} }`}))
       return result
     },
     staleTime: ${staleTime},
@@ -4005,16 +4112,18 @@ export function ${hookName.replace("use", "useSuspense")}(${parameterTypes.lengt
     return `/**
  * Optimized query hook for ${endpoint.method} ${endpoint.path}
  * Features: Smart caching, error handling, type safety
+ * @param params - Named parameters object with path and query parameters
+ * @param options - Query options
  * @returns useQuery result with data of type ${returnType}
  */
-export function ${hookName}(${parameterTypes.length > 0 ? `${parameterTypes.join(", ")}, ` : ""}options?: ${optionsType}) {
+export function ${hookName}(params${pathParameters.length > 0 ? "" : "?"}: ${paramsType}, options?: ${optionsType}) {
   const { initialData, ...restOptions } = options ?? {}
 
   return useQuery({
-    queryKey: ${queryKey},
+    queryKey: ['${toActionName(endpoint.operationId || endpoint.id)}', ${pathParameters.length > 0 ? "params?.path" : "null"}, params?.query],
     queryFn: async ({ signal }: { signal?: AbortSignal }) => {
       try {
-        const result = await resolveActionResult<${returnType}>(${actionCallParams === "{}" ? `${actionName}()` : `${actionName}(${actionCallParams})`})
+        const result = await resolveActionResult<${returnType}>(${actionName}(${pathParameters.length > 0 ? `{ path: ${pathParamsBuild}, query: ${queryParamsBuild} }` : `{ query: ${queryParamsBuild} }`}))
         return result
       } catch (error) {
         handleActionError(error)
@@ -4042,15 +4151,17 @@ export function ${hookName}(${parameterTypes.length > 0 ? `${parameterTypes.join
 
 /**
  * Suspense version for ${endpoint.path}
+ * @param params - Named parameters object with path and query parameters
+ * @param options - Query options
  * @returns useSuspenseQuery result with data of type ${returnType}
  */
-export function ${hookName.replace("use", "useSuspense")}(${parameterTypes.length > 0 ? `${parameterTypes.join(", ")}, ` : ""}options?: ${optionsType}) {
+export function ${hookName.replace("use", "useSuspense")}(params${pathParameters.length > 0 ? "" : "?"}: ${paramsType}, options?: ${optionsType}) {
   const { initialData, ...restOptions } = options ?? {}
 
   return useSuspenseQuery({
-    queryKey: ${queryKey},
+    queryKey: ['${toActionName(endpoint.operationId || endpoint.id)}', ${pathParameters.length > 0 ? "params?.path" : "null"}, params?.query],
     queryFn: async () => {
-      const result = await resolveActionResult<${returnType}>(${actionCallParams === "{}" ? `${actionName}()` : `${actionName}(${actionCallParams})`})
+      const result = await resolveActionResult<${returnType}>(${actionName}(${pathParameters.length > 0 ? `{ path: ${pathParamsBuild}, query: ${queryParamsBuild} }` : `{ query: ${queryParamsBuild} }`}))
       return result
     },
     staleTime: ${staleTime},
@@ -4165,7 +4276,7 @@ ${invalidationCode}
    * Find related queries that should be invalidated when this mutation runs
    */
   findRelatedQueries(endpoint, context) {
-    if (!context?.schema?.endpoints) {
+    if (!context?.schema.endpoints) {
       return [];
     }
     const relatedQueries = [];
@@ -4299,7 +4410,6 @@ ${invalidationCode}
   buildActionCallParams(endpoint, isMutation) {
     const pathParameters = endpoint.parameters.filter((parameter) => parameter.in === "path");
     const queryParameters = endpoint.parameters.filter((parameter) => parameter.in === "query");
-    !!endpoint.requestBody;
     if (isMutation) {
       return "variables";
     }
@@ -4380,13 +4490,13 @@ ${invalidationCode}
 import { useQuery, useMutation, useInfiniteQuery, useSuspenseQuery, type UseQueryOptions, type UseMutationOptions, type UseInfiniteQueryOptions, type UseSuspenseQueryOptions, type QueryKey, type QueryFunction } from '@tanstack/react-query'
 
 /**
- * Enhanced React Query wrapper hook with Next.js 16.0.1 optimizations
+ * Enhanced React Query wrapper hook with Next.js 16.0.7 optimizations
  * Provides consistent defaults across all queries following best practices
  * 
  * Features:
  * - React Query v5: Uses gcTime instead of cacheTime
  * - React Query v5: Uses placeholderData instead of keepPreviousData
- * - Next.js 16.0.1: Optimized for App Router and Server Components
+ * - Next.js 16.0.7: Optimized for App Router and Server Components
  */
 export function useBridgeQuery<TData = unknown, TError = Error>(
   queryKey: QueryKey,
@@ -4401,14 +4511,8 @@ export function useBridgeQuery<TData = unknown, TError = Error>(
     refetchOnWindowFocus: true,
     refetchOnReconnect: true,
     refetchOnMount: 'always',
-    // React Query v5: placeholderData cannot be a function type
-    // Use keepPreviousData pattern: return previousData if it exists and is not a function
-    placeholderData: (previousData) => {
-      if (previousData === undefined) return undefined
-      // Type guard: ensure we don't return a function (React Query v5 requirement)
-      if (typeof previousData === 'function') return undefined
-      return previousData
-    } as any,
+    // React Query v5: placeholderData returns previous data if available
+    placeholderData: (previousData) => previousData,
     retry: (failureCount: number, error: TError) => {
       if (error instanceof Error && error.message.includes('4')) return false
       return failureCount < 3
@@ -4421,15 +4525,17 @@ export function useBridgeQuery<TData = unknown, TError = Error>(
  * Enhanced infinite query wrapper
  * React Query v5: Optimized for paginated data with infinite scrolling
  */
-export function useBridgeInfiniteQuery<TData = unknown, TError = Error>(
+export function useBridgeInfiniteQuery<TData = unknown, TError = Error, TPageParam = number>(
   queryKey: QueryKey,
-  queryFn: QueryFunction<TData, QueryKey>,
-  options?: Partial<UseInfiniteQueryOptions<TData, TError, TData, QueryKey>>
+  queryFn: QueryFunction<TData, QueryKey, TPageParam>,
+  options?: Partial<UseInfiniteQueryOptions<TData, TError, TData, QueryKey, TPageParam>> & {
+    getNextPageParam?: (lastPage: TData, allPages: TData[]) => TPageParam | undefined
+  }
 ) {
-  return useInfiniteQuery<TData, TError>({
+  return useInfiniteQuery<TData, TError, TData, QueryKey, TPageParam>({
     queryKey,
-    initialPageParam: 1,
-    queryFn: queryFn as QueryFunction<TData, QueryKey>,
+    initialPageParam: 1 as TPageParam,
+    queryFn,
     staleTime: 5 * 60 * 1000,
     gcTime: 10 * 60 * 1000,
     refetchOnWindowFocus: true,
@@ -4439,13 +4545,15 @@ export function useBridgeInfiniteQuery<TData = unknown, TError = Error>(
       if (error instanceof Error && error.message.includes('4')) return false
       return failureCount < 3
     },
+    // Provide default getNextPageParam if not provided
+    getNextPageParam: options?.getNextPageParam || (() => undefined),
     ...options,
   })
 }
 
 /**
  * Enhanced suspense query wrapper
- * Next.js 16.0.1: Optimized for Server Components with Suspense
+ * Next.js 16.0.7: Optimized for Server Components with Suspense
  */
 export function useBridgeSuspenseQuery<TData = unknown, TError = Error>(
   queryKey: QueryKey,
@@ -4501,7 +4609,7 @@ var AuthGenerator = class {
     __name(this, "AuthGenerator");
   }
   buildImportPath(relativePath) {
-    const outputDirectory = this.configuration.outputDir || "generated";
+    const outputDirectory = this.configuration.outputDir ?? "generated";
     const cleanPath = relativePath.startsWith("/") ? relativePath.slice(1) : relativePath;
     let importBasePath = outputDirectory;
     if (importBasePath.startsWith("src/")) {
@@ -4509,11 +4617,11 @@ var AuthGenerator = class {
     }
     return `@/${importBasePath}/${cleanPath}`;
   }
-  async generate(context) {
+  generate(context) {
     const { config, schema } = context;
     const authConfig = config.auth;
     if (!authConfig?.enabled) {
-      return [];
+      return Promise.resolve([]);
     }
     const files = [];
     const authEndpoints = this.findAuthEndpoints(schema.endpoints);
@@ -4528,7 +4636,7 @@ var AuthGenerator = class {
     files.push(...this.generateAuthComponents(authEndpoints));
     files.push(this.generateAuthMiddleware());
     files.push(this.generateAuthContext());
-    return files;
+    return Promise.resolve(files);
   }
   findAuthEndpoints(endpoints) {
     const authEndpoints = {};
@@ -4561,12 +4669,12 @@ var AuthGenerator = class {
     }
     return userEndpoints;
   }
-  generateAuthSchemas(authEndpoints, schema) {
+  generateAuthSchemas(_authEndpoints, _schema) {
     this.buildImportPath("schemas");
-    const loginRequestSchema = authEndpoints.login?.requestBody?.content?.find(
+    const loginRequestSchema = _authEndpoints.login?.requestBody?.content?.find(
       (c) => c.type === "application/json"
     )?.schema;
-    const loginResponseSchema = authEndpoints.login?.responses?.find(
+    const loginResponseSchema = _authEndpoints.login?.responses?.find(
       (r) => r.statusCode === "200"
     )?.content?.[0]?.schema;
     const content = `import { z } from "zod"
@@ -4667,7 +4775,7 @@ export type Session = z.infer<typeof sessionSchema>`;
       }
     };
   }
-  generateAuthTypes(authEndpoints, schema) {
+  generateAuthTypes(_authEndpoints, _schema) {
     const schemasImport = this.buildImportPath("auth/schemas");
     const content = `// Auto-generated authentication types
 import type {
@@ -5213,7 +5321,7 @@ export const useRequireAuth = (redirectTo?: string) => {
       }
     };
   }
-  generateAuthActions(authEndpoints, userEndpoints) {
+  generateAuthActions(_authEndpoints, _userEndpoints) {
     const safeActionImport = this.buildImportPath("lib/safe-action");
     const schemasImport = this.buildImportPath("auth/schemas");
     const clientImport = this.buildImportPath("auth/client");
@@ -5445,7 +5553,7 @@ export const useCredentialsLogin = () => {
       }
     };
   }
-  generateAuthComponents(authEndpoints) {
+  generateAuthComponents(_authEndpoints) {
     const loginForm = {
       path: "auth/components/login-form.tsx",
       content: `"use client"
@@ -5565,7 +5673,6 @@ export function LoginForm() {
     return [loginForm];
   }
   generateAuthMiddleware() {
-    this.buildImportPath("auth/utils");
     const content = `import { NextResponse } from "next/server"
 import type { NextRequest } from "next/server"
 
@@ -5933,9 +6040,10 @@ var SchemaAnalyzer = class {
           }
           if (response.description) {
             const errorMatch = response.description.match(/error[_\s]?code[:\s]+(\w+)/i);
-            if (errorMatch) {
-              errorCodes.set(errorMatch[1].toLowerCase(), {
-                code: errorMatch[1],
+            if (errorMatch?.[1]) {
+              const errorCode = errorMatch[1];
+              errorCodes.set(errorCode.toLowerCase(), {
+                code: errorCode,
                 status,
                 message: response.description
               });
@@ -6021,7 +6129,7 @@ var SchemaAnalyzer = class {
     const endpoints = {};
     for (const endpoint of this.schema.endpoints) {
       const path3 = endpoint.path.toLowerCase();
-      const operationId = (endpoint.operationId || "").toLowerCase();
+      const operationId = (endpoint.operationId ?? "").toLowerCase();
       if ((path3.includes("/auth/login/credentials") || operationId.includes("logincredentials") || operationId.includes("signin")) && endpoint.method === "POST") {
         endpoints.loginCredentials = endpoint;
       } else if ((path3.includes("/auth/login") || operationId.includes("login")) && endpoint.method === "POST" && !endpoints.loginCredentials) {
@@ -6069,12 +6177,12 @@ var SchemaAnalyzer = class {
   extractSessionConfig() {
     const config = {};
     const sessionEndpoints = this.schema.endpoints.filter(
-      (e) => e.path.toLowerCase().includes("/session") || (e.operationId || "").toLowerCase().includes("session")
+      (e) => e.path.toLowerCase().includes("/session") || (e.operationId ?? "").toLowerCase().includes("session")
     );
     for (const endpoint of sessionEndpoints) {
       for (const response of endpoint.responses) {
         if (response.headers) {
-          for (const [headerName, headerDef] of Object.entries(response.headers)) {
+          for (const [headerName, _headerDef] of Object.entries(response.headers)) {
             if (headerName.toLowerCase().includes("expires") || headerName.toLowerCase().includes("max-age")) ;
           }
         }
@@ -6154,7 +6262,7 @@ var SchemaAnalyzer = class {
   /**
    * Check if OAuth provider is supported
    */
-  isOAuthProviderSupported(provider) {
+  isOAuthProviderSupported(_provider) {
     const extractedEndpoints = this.extractAuthEndpoints();
     return !!(extractedEndpoints.oauthAuthorize && extractedEndpoints.oauthCallback);
   }
@@ -6236,7 +6344,7 @@ var SchemaAnalyzer = class {
           errorCodes.set(code.toLowerCase(), {
             code,
             status,
-            message: schema.properties?.detail?.default || schema.properties?.message?.default || ""
+            message: schema.properties?.detail?.default ?? schema.properties?.message?.default ?? ""
           });
         });
       }
@@ -6245,9 +6353,10 @@ var SchemaAnalyzer = class {
       const detail = schema.properties.detail;
       if (typeof detail === "string") {
         const codeMatch = detail.match(/(\w+)[_\s]?error/i);
-        if (codeMatch) {
-          errorCodes.set(codeMatch[1].toLowerCase(), {
-            code: codeMatch[1],
+        if (codeMatch?.[1]) {
+          const errorCode = codeMatch[1];
+          errorCodes.set(errorCode.toLowerCase(), {
+            code: errorCode,
             status,
             message: detail
           });
@@ -6259,11 +6368,11 @@ var SchemaAnalyzer = class {
     if (!schema || typeof schema !== "object") return;
     if (schema.properties?.file) {
       const fileSchema = schema.properties.file;
-      if (fileSchema.maxSize || fileSchema["x-max-size"]) {
-        config.maxSize = fileSchema.maxSize || fileSchema["x-max-size"];
+      if (fileSchema.maxSize ?? fileSchema["x-max-size"]) {
+        config.maxSize = fileSchema.maxSize ?? fileSchema["x-max-size"];
       }
-      if (fileSchema.allowedTypes || fileSchema["x-allowed-types"]) {
-        config.allowedTypes = fileSchema.allowedTypes || fileSchema["x-allowed-types"];
+      if (fileSchema.allowedTypes ?? fileSchema["x-allowed-types"]) {
+        config.allowedTypes = fileSchema.allowedTypes ?? fileSchema["x-allowed-types"];
       }
     }
     if (schema["x-file-constraints"]) {
@@ -6283,7 +6392,7 @@ var NextAuthGenerator = class {
   analyzer;
   accountStatusPatterns;
   buildImportPath(relativePath) {
-    const outputDirectory = this.configuration.outputDir || "generated";
+    const outputDirectory = this.configuration.outputDir ?? "generated";
     const cleanPath = relativePath.startsWith("/") ? relativePath.slice(1) : relativePath;
     let importBasePath = outputDirectory;
     if (importBasePath.startsWith("src/")) {
@@ -6291,11 +6400,11 @@ var NextAuthGenerator = class {
     }
     return `@/${importBasePath}/${cleanPath}`;
   }
-  async generate(context) {
+  generate(context) {
     const { config, schema } = context;
     const authConfig = config.auth;
     if (!authConfig?.enabled || authConfig.provider !== "next-auth") {
-      return [];
+      return Promise.resolve([]);
     }
     this.analyzer = new SchemaAnalyzer(schema);
     this.accountStatusPatterns = this.analyzer.extractAccountStatusPatterns();
@@ -6312,7 +6421,7 @@ var NextAuthGenerator = class {
       console.warn("These features will be disabled in generated code.\n");
     }
     const detectedOAuthProviders = this.analyzer.extractOAuthProviders();
-    const configuredOAuthProviders = authConfig.oauth?.providers || [];
+    const configuredOAuthProviders = authConfig.oauth?.providers ?? [];
     const validOAuthProviders = configuredOAuthProviders.filter(
       (provider) => this.analyzer.isOAuthProviderSupported(provider)
     );
@@ -6323,7 +6432,7 @@ var NextAuthGenerator = class {
       console.warn(
         `\u26A0\uFE0F  NextAuth is enabled but login endpoints are not found in OpenAPI schema. Expected endpoints: /auth/login or /auth/login/credentials. NextAuth configuration will not be generated.`
       );
-      return files;
+      return Promise.resolve(files);
     }
     files.push(this.generateNextAuthConfig(
       extractedEndpoints,
@@ -6336,7 +6445,7 @@ var NextAuthGenerator = class {
     if (hasPasskeys) {
       files.push(this.generatePasskeyUtils(extractedEndpoints));
     }
-    return files;
+    return Promise.resolve(files);
   }
   findAuthEndpoints(endpoints) {
     const authEndpoints = {};
@@ -6439,14 +6548,14 @@ var NextAuthGenerator = class {
   }
   generateNextAuthConfig(extractedEndpoints, oauthProviders, hasMFA, hasPasskeys) {
     const authConfig = this.configuration.auth;
-    const apiBaseUrl = this.configuration.api?.baseUrl || "http://localhost:8000";
+    const apiBaseUrl = this.configuration.api.baseUrl || "http://localhost:8000";
     const apiUrl = `process.env.NEXT_PUBLIC_API_URL || '${apiBaseUrl}'`;
     const hasGoogle = oauthProviders.includes("google");
     const hasGitHub = oauthProviders.includes("github");
     oauthProviders.includes("discord");
     oauthProviders.includes("microsoft");
     oauthProviders.includes("apple");
-    const { activeStatuses, inactiveStatuses, suspendedStatuses, lockedStatuses } = this.accountStatusPatterns;
+    const { activeStatuses, inactiveStatuses, suspendedStatuses, lockedStatuses: _lockedStatuses } = this.accountStatusPatterns;
     this.analyzer.extractErrorCodes();
     const sessionStrategy = authConfig.session?.strategy || "jwt";
     const sessionMaxAge = authConfig.session?.maxAge || 7 * 24 * 60 * 60;
@@ -6995,7 +7104,7 @@ export async function authenticateWithPasskey(email?: string) {
       }
     };
   }
-  generateAuthTypes(authEndpoints, accountStatusPatterns) {
+  generateAuthTypes(_authEndpoints, _accountStatusPatterns) {
     const content = `/**
  * Authentication Types
  * Auto-generated by Mulink
@@ -7066,7 +7175,7 @@ export class AccountInactiveError extends AuthError {
       }
     };
   }
-  generateAuthUtils(authEndpoints) {
+  generateAuthUtils(_authEndpoints) {
     const content = `/**
  * Authentication Utilities
  * Auto-generated by Mulink
@@ -7119,7 +7228,7 @@ export async function requireAuth() {
       }
     };
   }
-  generatePasskeyUtils(passkeyEndpoints) {
+  generatePasskeyUtils(_passkeyEndpoints) {
     const content = `/**
  * Passkey (WebAuthn) Utilities
  * Auto-generated by Mulink
@@ -7172,7 +7281,7 @@ var MiddlewareGenerator = class {
     __name(this, "MiddlewareGenerator");
   }
   buildImportPath(relativePath) {
-    const outputDirectory = this.configuration.outputDir || "generated";
+    const outputDirectory = this.configuration.outputDir ?? "generated";
     const cleanPath = relativePath.startsWith("/") ? relativePath.slice(1) : relativePath;
     let importBasePath = outputDirectory;
     if (importBasePath.startsWith("src/")) {
@@ -7180,7 +7289,7 @@ var MiddlewareGenerator = class {
     }
     return `@/${importBasePath}/${cleanPath}`;
   }
-  async generate(context) {
+  generate(_context) {
     const files = [];
     files.push(this.generateMainMiddleware());
     files.push(this.generateRateLimitMiddleware());
@@ -7188,7 +7297,7 @@ var MiddlewareGenerator = class {
     files.push(this.generateSecurityMiddleware());
     files.push(this.generateLoggingMiddleware());
     files.push(this.generateApiMiddleware());
-    return files;
+    return Promise.resolve(files);
   }
   generateMainMiddleware() {
     const authImport = this.buildImportPath("auth/middleware");
@@ -7595,7 +7704,7 @@ var UploadGenerator = class {
   }
   analyzer;
   buildImportPath(relativePath) {
-    const outputDirectory = this.configuration.outputDir || "generated";
+    const outputDirectory = this.configuration.outputDir ?? "generated";
     const cleanPath = relativePath.startsWith("/") ? relativePath.slice(1) : relativePath;
     let importBasePath = outputDirectory;
     if (importBasePath.startsWith("src/")) {
@@ -7603,19 +7712,19 @@ var UploadGenerator = class {
     }
     return `@/${importBasePath}/${cleanPath}`;
   }
-  async generate(context) {
+  generate(context) {
     const { schema } = context;
     const generatedFiles = [];
     this.analyzer = new SchemaAnalyzer(schema);
     const uploadEndpoints = schema.endpoints.filter(
-      (endpoint) => endpoint.requestBody?.content?.some(
+      (endpoint) => endpoint.requestBody?.content.some(
         (content) => content.type === "multipart/form-data" || content.type === "application/octet-stream"
       )
     );
     if (uploadEndpoints.length === 0 || !this.configuration.uploads?.enabled) {
-      return generatedFiles;
+      return Promise.resolve(generatedFiles);
     }
-    const presignedConfig = this.configuration.uploads?.presignedUploads;
+    const presignedConfig = this.configuration.uploads.presignedUploads;
     if (presignedConfig?.enabled) {
       const isPresignedSupported = this.analyzer.isPresignedUploadsSupported();
       if (!isPresignedSupported) {
@@ -7626,14 +7735,14 @@ var UploadGenerator = class {
     }
     const extractedUploadConfig = this.analyzer.extractUploadConfig();
     const presignedEnabled = presignedConfig?.enabled && this.analyzer.isPresignedUploadsSupported();
-    const uploadProvider = this.configuration.uploads?.provider || (extractedUploadConfig.presignedEndpoint ? "minio" : "standard");
-    const uploadStrategy = presignedEnabled ? "presigned" : this.configuration.uploads?.strategy || "standard";
+    const uploadProvider = this.configuration.uploads.provider || (extractedUploadConfig.presignedEndpoint ? "minio" : "standard");
+    const uploadStrategy = presignedEnabled ? "presigned" : this.configuration.uploads.strategy || "standard";
     presignedEnabled ? {
-      presignEndpoint: extractedUploadConfig.presignedEndpoint || presignedConfig?.presignEndpoint || "/api/v1/files/presign-upload",
-      fallbackToBackend: presignedConfig?.fallbackToBackend !== false
+      presignEndpoint: extractedUploadConfig.presignedEndpoint || presignedConfig.presignEndpoint || "/api/v1/files/presign-upload",
+      fallbackToBackend: presignedConfig.fallbackToBackend !== false
     } : {
       };
-    const progressConfig = this.configuration.uploads?.progressTracking || {
+    const progressConfig = this.configuration.uploads.progressTracking || {
       enabled: true,
       useXHR: true
     };
@@ -7650,7 +7759,7 @@ var UploadGenerator = class {
         progressConfig
       ));
     }
-    return generatedFiles;
+    return Promise.resolve(generatedFiles);
   }
   /**
    * Find presigned upload endpoint in schema
@@ -7663,7 +7772,7 @@ var UploadGenerator = class {
       return pathLower.includes("presign") || pathLower.includes("presigned") || operationIdLower.includes("presign") || operationIdLower.includes("presigned");
     }) || null;
   }
-  generateUploadUtilities(uploadProvider, uploadStrategy, presignedEndpoint) {
+  generateUploadUtilities(_uploadProvider, _uploadStrategy, _presignedEndpoint) {
     const { uploads } = this.configuration;
     const extractedConfig = this.analyzer.extractUploadConfig();
     const maxSize = uploads?.security?.maxSize || (extractedConfig.maxSize ? `${extractedConfig.maxSize}MB` : "10MB");
@@ -8014,8 +8123,8 @@ async function uploadViaBackendApi(
     xhr.responseType = 'json'
     // Use base URL from environment or configuration
     const baseUrl = typeof window !== 'undefined' 
-      ? (process.env.NEXT_PUBLIC_API_URL || '${this.configuration.api?.baseUrl || "http://localhost:8000"}')
-      : '${this.configuration.api?.baseUrl || "http://localhost:8000"}'
+      ? (process.env.NEXT_PUBLIC_API_URL || '${this.configuration.api.baseUrl || "http://localhost:8000"}')
+      : '${this.configuration.api.baseUrl || "http://localhost:8000"}'
     xhr.open('POST', \`\${baseUrl}${endpoint.path}\`)
     xhr.send(formData)
   })
@@ -8290,8 +8399,8 @@ export function ${hookName}Upload(options?: {
   }
   generateUseUploadFileHook(uploadProvider, uploadStrategy, context) {
     const uploadUtilsImport = this.buildImportPath("services/uploadUtils");
-    const uploadEndpoints = context?.schema?.endpoints?.filter(
-      (e) => e.metadata?.fileUpload || e.path.toLowerCase().includes("upload") || e.operationId && e.operationId.toLowerCase().includes("upload")
+    const uploadEndpoints = context?.schema.endpoints.filter(
+      (e) => e.metadata.fileUpload || e.path.toLowerCase().includes("upload") || e.operationId && e.operationId.toLowerCase().includes("upload")
     ) || [];
     const firstUploadEndpoint = uploadEndpoints[0];
     let uploadMethodName = "uploadFile";
@@ -8431,7 +8540,7 @@ var ErrorHandlerGenerator = class {
   }
   analyzer;
   buildImportPath(relativePath) {
-    const outputDirectory = this.configuration.outputDir || "generated";
+    const outputDirectory = this.configuration.outputDir ?? "generated";
     const cleanPath = relativePath.startsWith("/") ? relativePath.slice(1) : relativePath;
     let importBasePath = outputDirectory;
     if (importBasePath.startsWith("src/")) {
@@ -8439,18 +8548,18 @@ var ErrorHandlerGenerator = class {
     }
     return `@/${importBasePath}/${cleanPath}`;
   }
-  async generate(context) {
+  generate(context) {
     const files = [];
-    const { schema, config } = context;
+    const { schema } = context;
     const { api } = this.configuration;
-    const errorHandling = api?.errorHandling;
+    const errorHandling = api.errorHandling;
     this.analyzer = new SchemaAnalyzer(schema);
     const errorCodes = this.analyzer.extractErrorCodes();
     const accountStatusPatterns = this.analyzer.extractAccountStatusPatterns();
     const extractedAuthEndpoints = this.analyzer.extractAuthEndpoints();
     const hasAuthEndpoints = !!(extractedAuthEndpoints.login || extractedAuthEndpoints.loginCredentials);
     const hasAuthErrors = errorCodes.size > 0 || (accountStatusPatterns.inactiveStatuses.length > 0 || accountStatusPatterns.suspendedStatuses.length > 0);
-    const shouldGenerate = hasAuthEndpoints && (errorHandling?.generateAuthErrorHandler !== false && errorHandling?.enableAuthErrorHandling !== false || hasAuthErrors && errorHandling?.generateAuthErrorHandler !== false);
+    const shouldGenerate = hasAuthEndpoints && (errorHandling?.generateAuthErrorHandler !== false && errorHandling?.enableAuthErrorHandling !== false || hasAuthErrors && errorHandling.generateAuthErrorHandler !== false);
     if (shouldGenerate) {
       files.push(this.generateAuthErrorHandler(errorCodes, accountStatusPatterns));
     } else if (errorHandling?.enableAuthErrorHandling === true && !hasAuthEndpoints) {
@@ -8458,11 +8567,11 @@ var ErrorHandlerGenerator = class {
         `\u26A0\uFE0F  Auth error handling is enabled but auth endpoints are not found in OpenAPI schema. Auth error handler will not be generated.`
       );
     }
-    return files;
+    return Promise.resolve(files);
   }
   generateAuthErrorHandler(errorCodes, accountStatusPatterns) {
     const authPath = this.configuration.auth?.authPath || "@/lib/auth";
-    const errorHandling = this.configuration.api?.errorHandling;
+    const errorHandling = this.configuration.api.errorHandling;
     const authErrorHandlerPath = errorHandling?.authErrorHandlerPath || "@/lib/auth-error-handler";
     let handlerOutputPath = authErrorHandlerPath;
     if (handlerOutputPath.startsWith("@/")) {
@@ -8501,7 +8610,7 @@ async function getToast(): Promise<{
   try {
     // Try to import sonner (common toast library)
     const sonner = await import('sonner')
-    toast = sonner
+    toast = sonner.toast
     return toast
   } catch {
     // Fallback to console if toast library not available
@@ -8675,7 +8784,7 @@ var SSEGenerator = class {
   }
   analyzer;
   buildImportPath(relativePath) {
-    const outputDirectory = this.configuration.outputDir || "generated";
+    const outputDirectory = this.configuration.outputDir ?? "generated";
     const cleanPath = relativePath.startsWith("/") ? relativePath.slice(1) : relativePath;
     let importBasePath = outputDirectory;
     if (importBasePath.startsWith("src/")) {
@@ -8707,11 +8816,11 @@ var SSEGenerator = class {
     );
     return hasEventStream;
   }
-  async generate(context) {
+  generate(context) {
     const { schema } = context;
     const generatedFiles = [];
     this.analyzer = new SchemaAnalyzer(schema);
-    const streamingConfig = this.configuration.framework?.streaming;
+    const streamingConfig = this.configuration.framework.streaming;
     const hasStreamingEndpoints = schema.endpoints.some((endpoint) => this.isSSEEndpoint(endpoint));
     if (streamingConfig?.enabled === true && !hasStreamingEndpoints) {
       console.warn(
@@ -8720,11 +8829,11 @@ var SSEGenerator = class {
     }
     const shouldEnableStreaming = streamingConfig?.enabled === true ? hasStreamingEndpoints : streamingConfig?.enabled !== false && hasStreamingEndpoints;
     if (!shouldEnableStreaming || streamingConfig?.sse?.enabled === false || !hasStreamingEndpoints) {
-      return generatedFiles;
+      return Promise.resolve(generatedFiles);
     }
     const sseEndpoints = schema.endpoints.filter((endpoint) => this.isSSEEndpoint(endpoint));
     if (sseEndpoints.length === 0) {
-      return generatedFiles;
+      return Promise.resolve(generatedFiles);
     }
     for (const endpoint of sseEndpoints) {
       generatedFiles.push(this.generateSSEClientMethod(endpoint));
@@ -8733,7 +8842,7 @@ var SSEGenerator = class {
     for (const [tag, tagEndpoints] of Object.entries(endpointsByTag)) {
       generatedFiles.push(this.generateSSEHooks(tag, tagEndpoints));
     }
-    return generatedFiles;
+    return Promise.resolve(generatedFiles);
   }
   generateSSEClientMethod(endpoint) {
     const operationId = endpoint.operationId || endpoint.id;
@@ -8768,8 +8877,8 @@ var SSEGenerator = class {
   }): EventSource => {
     ${pathParamNames.length > 0 ? `const { ${pathParamNames.join(", ")}, ...restOptions } = options.params || {}
     ` : ""}const baseUrl = typeof window !== 'undefined' 
-      ? (process.env.NEXT_PUBLIC_API_URL || '${this.configuration.api?.baseUrl || "http://localhost:8000"}')
-      : '${this.configuration.api?.baseUrl || "http://localhost:8000"}'
+      ? (process.env.NEXT_PUBLIC_API_URL || '${this.configuration.api.baseUrl || "http://localhost:8000"}')
+      : '${this.configuration.api.baseUrl || "http://localhost:8000"}'
     const sseUrl = \`\${baseUrl}${urlConstruction}\`
 
     // Create EventSource connection
@@ -8815,7 +8924,7 @@ var SSEGenerator = class {
   generateSSEHooks(tag, endpoints) {
     const tagName = toValidIdentifier(tag);
     const clientImport = this.buildImportPath("client");
-    const streamingConfig = this.configuration.framework?.streaming?.sse;
+    const streamingConfig = this.configuration.framework.streaming?.sse;
     const autoReconnect = streamingConfig?.autoReconnect !== false;
     const reconnectDelay = streamingConfig?.reconnectDelay || 3e3;
     const maxReconnectAttempts = streamingConfig?.maxReconnectAttempts || 5;
@@ -9008,7 +9117,7 @@ var NextJsCodeGenerator = class {
     __name(this, "NextJsCodeGenerator");
   }
   buildImportPath(relativePath) {
-    const outputDirectory = this.configuration.outputDir || "generated";
+    const outputDirectory = this.configuration.outputDir ?? "generated";
     const cleanPath = relativePath.startsWith("/") ? relativePath.slice(1) : relativePath;
     let importBasePath = outputDirectory;
     if (importBasePath.startsWith("src/")) {
@@ -9022,9 +9131,9 @@ var NextJsCodeGenerator = class {
       path: file.path,
       metadata: {
         ...file.metadata,
-        exports: file.metadata?.exports || [],
-        imports: file.metadata?.imports || [],
-        dependencies: file.metadata?.dependencies?.map((dependency) => {
+        exports: file.metadata?.exports ?? [],
+        imports: file.metadata?.imports ?? [],
+        dependencies: file.metadata?.dependencies.map((dependency) => {
           if (dependency.startsWith("@/generated/")) {
             return dependency;
           }
@@ -9033,7 +9142,7 @@ var NextJsCodeGenerator = class {
             return `@/generated/${relativePart}`;
           }
           return dependency;
-        }) || []
+        }) ?? []
       }
     }));
   }
@@ -9066,11 +9175,11 @@ var NextJsCodeGenerator = class {
         const uploadGenerator = new UploadGenerator(this.configuration);
         generatedFiles.push(...await uploadGenerator.generate(context));
       }
-      if (this.configuration.api?.errorHandling?.generateAuthErrorHandler !== false) {
+      if (this.configuration.api.errorHandling?.generateAuthErrorHandler !== false) {
         const errorHandlerGenerator = new ErrorHandlerGenerator(this.configuration);
         generatedFiles.push(...await errorHandlerGenerator.generate(context));
       }
-      if (this.configuration.framework?.streaming?.enabled) {
+      if (this.configuration.framework.streaming?.enabled) {
         const sseGenerator = new SSEGenerator(this.configuration);
         generatedFiles.push(...await sseGenerator.generate(context));
       }
@@ -9080,14 +9189,14 @@ var NextJsCodeGenerator = class {
       throw new GenerationError(`Failed to generate Next.js files: ${errorMessage}`);
     }
   }
-  async generateSafeActionClient() {
+  generateSafeActionClient() {
     const safeActionContent = `import { DEFAULT_SERVER_ERROR_MESSAGE, createSafeActionClient } from "next-safe-action";
 import { headers } from "next/headers";
 import { z } from "zod";
 
 /**
  * Enhanced Action Error class for better error handling
- * Follows Next.js 16.0.1 best practices
+ * Follows Next.js 16.0.7 best practices
  */
 export class ActionError extends Error {
   constructor(
@@ -9124,7 +9233,7 @@ export const actionClient = createSafeActionClient({
 
 /**
  * Enhanced action client with metadata support
- * Next.js 16.0.1: Supports metadata for better action tracking and rate limiting
+ * Next.js 16.0.7: Supports metadata for better action tracking and rate limiting
  */
 export const actionClientWithMeta = createSafeActionClient({
   handleServerError(e) {
@@ -9145,7 +9254,7 @@ export const actionClientWithMeta = createSafeActionClient({
         requests: z.number().int().positive().describe('Number of requests allowed'),
         window: z.string().describe('Time window (e.g., "10s", "1m", "1h")'),
       }).optional().describe('Rate limiting configuration'),
-      cacheTags: z.array(z.string()).optional().describe('Cache tags for invalidation (Next.js 16.0.1)'),
+      cacheTags: z.array(z.string()).optional().describe('Cache tags for invalidation (Next.js 16.0.7)'),
     });
   },
 });
@@ -9236,7 +9345,7 @@ async function getCurrentUser() {
   // Implement your authentication logic here
   return null;
 }`;
-    return [
+    return Promise.resolve([
       {
         path: "lib/safe-action.ts",
         content: safeActionContent,
@@ -9247,7 +9356,7 @@ async function getCurrentUser() {
           dependencies: []
         }
       }
-    ];
+    ]);
   }
 };
 var FileSystemManager = class {
@@ -9255,7 +9364,7 @@ var FileSystemManager = class {
     __name(this, "FileSystemManager");
   }
   async writeFile(filePath, content, options = {}) {
-    if (!filePath?.trim()) {
+    if (!filePath.trim()) {
       throw new Error("File path is required and cannot be empty");
     }
     if (typeof content !== "string") {
@@ -9292,7 +9401,7 @@ var FileSystemManager = class {
     }
   }
   async readFile(filePath, encoding = "utf8") {
-    if (!filePath?.trim()) {
+    if (!filePath.trim()) {
       throw new Error("File path is required and cannot be empty");
     }
     try {
@@ -9319,7 +9428,7 @@ var FileSystemManager = class {
     }
   }
   async getFileHash(filePath) {
-    if (!filePath?.trim()) {
+    if (!filePath.trim()) {
       throw new Error("File path is required and cannot be empty");
     }
     try {
@@ -9345,7 +9454,7 @@ var FileSystemManager = class {
     }
   }
   async findFiles(dir, pattern, recursive = true) {
-    if (!dir?.trim()) {
+    if (!dir.trim()) {
       throw new Error("Directory path is required and cannot be empty");
     }
     if (!(pattern instanceof RegExp)) {
@@ -9388,16 +9497,52 @@ var BridgeCore = class {
   logger;
   schemaParser;
   fileManager;
+  /**
+   * Creates a new instance of BridgeCore
+   * 
+   * Initializes all required dependencies including logger, schema parser, and file manager.
+   * All dependencies are readonly to ensure immutability and thread safety.
+   */
   constructor() {
     this.logger = new BridgeLogger({ prefix: "\u{1F517} Mulink" });
     this.schemaParser = new OpenApiSchemaParser();
     this.fileManager = new FileSystemManager();
   }
+  /**
+   * Generates type-safe API client code from OpenAPI schema
+   * 
+   * This is the main entry point for code generation. It validates the configuration,
+   * parses the OpenAPI schema, generates all necessary files, and writes them to disk.
+   * 
+   * The generated code follows Next.js 16.0.7 best practices including:
+   * - Server Actions with type safety
+   * - React Query hooks with proper caching
+   * - Middleware support
+   * - Error handling
+   * - Cache tag management
+   * 
+   * @param configuration - The bridge configuration containing schema URL, output directory, and framework settings
+   * @returns Promise that resolves when generation is complete
+   * @throws {ValidationError} When configuration is invalid
+   * @throws {SchemaParseError} When OpenAPI schema cannot be parsed
+   * @throws {GenerationError} When code generation fails
+   * 
+   * @example
+   * ```typescript
+   * const config: BridgeConfiguration = {
+   *   schema: 'https://api.example.com/openapi.json',
+   *   outputDir: 'src/generated',
+   *   framework: { type: 'nextjs', router: 'app', features: {...} },
+   *   api: { baseUrl: 'https://api.example.com', timeout: 30000, retries: 3 }
+   * };
+   * await bridge.generate(config);
+   * ```
+   */
   async generate(configuration) {
     const startTime = Date.now();
     try {
       this.logger.info("Starting code generation...");
-      await this.validateConfiguration(configuration);
+      this.validateConfiguration(configuration);
       this.logger.info(`Parsing schema: ${configuration.schema}`);
       const parsedSchema = await this.schemaParser.parse(configuration.schema);
       this.logger.debug(
@@ -9426,16 +9571,17 @@ var BridgeCore = class {
       throw error;
     }
   }
-  async validateConfiguration(configuration) {
+  validateConfiguration(configuration) {
     const errors = [];
-    if (!configuration.schema?.trim()) {
+    if (!configuration.schema.trim()) {
       errors.push("Schema URL is required and cannot be empty");
     }
-    if (!configuration.outputDir?.trim()) {
+    if (!configuration.outputDir.trim()) {
       errors.push("Output directory is required and cannot be empty");
     }
     if (configuration.framework.type !== "nextjs") {
-      errors.push(`Only Next.js framework is currently supported, got: ${configuration.framework.type}`);
+      const frameworkType = configuration.framework.type;
+      errors.push(`Only Next.js framework is currently supported, got: ${frameworkType}`);
     }
     if (errors.length > 0) {
       throw new ValidationError(
@@ -9452,8 +9598,10 @@ var BridgeCore = class {
         case "nextjs":
           const nextJsGenerator = new NextJsCodeGenerator(config);
           return await nextJsGenerator.generate(context);
-        default:
-          throw new GenerationError(`Unsupported framework: ${config.framework.type}`);
+        default: {
+          const frameworkType = config.framework.type;
+          throw new GenerationError(`Unsupported framework: ${frameworkType}`);
+        }
       }
     } catch (error) {
       if (error instanceof GenerationError) {
@@ -9487,7 +9635,7 @@ var BridgeCore = class {
   logGenerationSummary(files) {
     const fileTypes = files.reduce(
       (acc, file) => {
-        acc[file.type] = (acc[file.type] || 0) + 1;
+        acc[file.type] = (acc[file.type] ?? 0) + 1;
         return acc;
       },
       {}
@@ -9506,9 +9654,24 @@ var BridgeCore = class {
       });
     }
   }
-  // Public API methods
+  /**
+   * Validates an OpenAPI schema without generating code
+   * 
+   * Useful for checking schema validity before running full generation.
+   * 
+   * @param schemaUrl - URL or file path to the OpenAPI schema
+   * @returns Promise resolving to true if schema is valid, false otherwise
+   * 
+   * @example
+   * ```typescript
+   * const isValid = await bridge.validateSchema('https://api.example.com/openapi.json');
+   * if (isValid) {
+   *   await bridge.generate(config);
+   * }
+   * ```
+   */
   async validateSchema(schemaUrl) {
-    if (!schemaUrl?.trim()) {
+    if (!schemaUrl.trim()) {
       this.logger.warn("Schema URL is empty or invalid");
       return false;
     }
@@ -9522,8 +9685,25 @@ var BridgeCore = class {
       return false;
     }
   }
+  /**
+   * Retrieves metadata from an OpenAPI schema
+   * 
+   * Extracts schema metadata including title, version, description, and other
+   * OpenAPI document information without parsing the entire schema.
+   * 
+   * @param schemaUrl - URL or file path to the OpenAPI schema
+   * @returns Promise resolving to schema metadata
+   * @throws {BridgeError} When schema URL is invalid
+   * @throws {SchemaParseError} When schema cannot be parsed
+   * 
+   * @example
+   * ```typescript
+   * const metadata = await bridge.getSchemaInfo('https://api.example.com/openapi.json');
+   * console.log(`Schema: ${metadata.title} v${metadata.version}`);
+   * ```
+   */
   async getSchemaInfo(schemaUrl) {
-    if (!schemaUrl?.trim()) {
+    if (!schemaUrl.trim()) {
       throw new BridgeError("Schema URL is required and cannot be empty", "INVALID_SCHEMA_URL");
     }
     try {
@@ -9535,6 +9715,18 @@ var BridgeCore = class {
       throw new SchemaParseError(`Failed to parse schema: ${errorMessage}`, schemaUrl);
     }
   }
+  /**
+   * Clears the internal schema cache
+   * 
+   * Useful when you need to force re-fetching of schemas or during development.
+   * The cache is automatically managed, but this method allows manual invalidation.
+   * 
+   * @example
+   * ```typescript
+   * bridge.clearCache();
+   * await bridge.generate(config); // Will fetch fresh schema
+   * ```
+   */
   clearCache() {
     try {
       this.schemaParser.clearCache();
@@ -9633,7 +9825,7 @@ var ConfigurationLoader = class {
   }
   async load(configPath) {
     if (!configPath?.trim()) {
-      configPath = "mulink.config.json";
+      configPath = "link.config.json";
     }
     const resolvedPath = path2__default.default.resolve(process.cwd(), configPath);
     try {
@@ -9699,7 +9891,7 @@ ${errorMessages}`,
       );
     }
   }
-  async createDefault(framework = "nextjs") {
+  createDefault(framework = "nextjs") {
     const defaultConfig = {
       schema: "https://petstore3.swagger.io/api/v3/openapi.json",
       outputDir: "src/generated",
@@ -9744,7 +9936,7 @@ ${errorMessages}`,
   }
   async save(config, configPath) {
     if (!configPath?.trim()) {
-      configPath = "mulink.config.json";
+      configPath = "link.config.json";
     }
     const resolvedPath = path2__default.default.resolve(process.cwd(), configPath);
     try {
@@ -9802,5 +9994,5 @@ exports.VersionChecker = VersionChecker;
 exports.__name = __name;
 exports.checkAndNotifyUpdates = checkAndNotifyUpdates;
 exports.createBridgeVersionChecker = createBridgeVersionChecker;
-//# sourceMappingURL=chunk-RGFU7SMN.cjs.map
-//# sourceMappingURL=chunk-RGFU7SMN.cjs.map
+//# sourceMappingURL=chunk-NC747MZJ.cjs.map
+//# sourceMappingURL=chunk-NC747MZJ.cjs.map