blaizejs 0.2.3 → 0.3.0

package/dist/index.cjs

@@ -1,5 +1,5 @@
 /**
- * blaizejs v0.2.3
+ * blaizejs v0.3.0
  * A blazing-fast, TypeScript-first Node.js framework with HTTP/2 support, file-based routing, powerful middleware system, and end-to-end type safety for building modern APIs.
  * 
  * Copyright (c) 2025 BlaizeJS Contributors
@@ -13,6 +13,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -35,15 +38,276 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// ../blaize-types/src/errors.ts
+function isBodyParseError(error) {
+  return typeof error === "object" && error !== null && "type" in error && "message" in error && "error" in error && typeof error.type === "string" && typeof error.message === "string";
+}
+var ErrorType, ErrorSeverity, BlaizeError;
+var init_errors = __esm({
+  "../blaize-types/src/errors.ts"() {
+    "use strict";
+    ErrorType = /* @__PURE__ */ ((ErrorType2) => {
+      ErrorType2["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+      ErrorType2["NOT_FOUND"] = "NOT_FOUND";
+      ErrorType2["UNAUTHORIZED"] = "UNAUTHORIZED";
+      ErrorType2["FORBIDDEN"] = "FORBIDDEN";
+      ErrorType2["CONFLICT"] = "CONFLICT";
+      ErrorType2["RATE_LIMITED"] = "RATE_LIMITED";
+      ErrorType2["INTERNAL_SERVER_ERROR"] = "INTERNAL_SERVER_ERROR";
+      ErrorType2["PAYLOAD_TOO_LARGE"] = "PAYLOAD_TOO_LARGE";
+      ErrorType2["UNSUPPORTED_MEDIA_TYPE"] = "UNSUPPORTED_MEDIA_TYPE";
+      ErrorType2["UPLOAD_TIMEOUT"] = "UPLOAD_TIMEOUT";
+      ErrorType2["UNPROCESSABLE_ENTITY"] = "UNPROCESSABLE_ENTITY";
+      ErrorType2["NETWORK_ERROR"] = "NETWORK_ERROR";
+      ErrorType2["TIMEOUT_ERROR"] = "TIMEOUT_ERROR";
+      ErrorType2["PARSE_ERROR"] = "PARSE_ERROR";
+      ErrorType2["HTTP_ERROR"] = "HTTP_ERROR";
+      return ErrorType2;
+    })(ErrorType || {});
+    ErrorSeverity = /* @__PURE__ */ ((ErrorSeverity2) => {
+      ErrorSeverity2["LOW"] = "low";
+      ErrorSeverity2["MEDIUM"] = "medium";
+      ErrorSeverity2["HIGH"] = "high";
+      ErrorSeverity2["CRITICAL"] = "critical";
+      return ErrorSeverity2;
+    })(ErrorSeverity || {});
+    BlaizeError = class extends Error {
+      /**
+       * Error type identifier from the ErrorType enum
+       * Used for programmatic error handling and client-side error routing
+       */
+      type;
+      /**
+       * Human-readable error title/message
+       * Should be descriptive enough for debugging but safe for end users
+       */
+      title;
+      /**
+       * HTTP status code associated with this error
+       * Used by the error boundary to set appropriate response status
+       */
+      status;
+      /**
+       * Correlation ID for request tracing
+       * Links this error to the specific request that generated it
+       */
+      correlationId;
+      /**
+       * Timestamp when the error occurred
+       * Useful for debugging and log correlation
+       */
+      timestamp;
+      /**
+       * Additional error-specific details
+       * Type-safe error context that varies by error type
+       */
+      details;
+      /**
+       * Creates a new BlaizeError instance
+       *
+       * @param type - Error type from the ErrorType enum
+       * @param title - Human-readable error message
+       * @param status - HTTP status code
+       * @param correlationId - Request correlation ID for tracing
+       * @param details - Optional error-specific details
+       */
+      constructor(type, title, status, correlationId, details) {
+        super(title);
+        this.name = this.constructor.name;
+        this.type = type;
+        this.title = title;
+        this.status = status;
+        this.correlationId = correlationId;
+        this.timestamp = /* @__PURE__ */ new Date();
+        this.details = details;
+        Object.setPrototypeOf(this, new.target.prototype);
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(this, this.constructor);
+        }
+      }
+      /**
+       * Serializes the error to a plain object suitable for HTTP responses
+       *
+       * @returns Object representation of the error
+       */
+      toJSON() {
+        const base = {
+          type: this.type,
+          title: this.title,
+          status: this.status,
+          correlationId: this.correlationId,
+          timestamp: this.timestamp.toISOString()
+        };
+        if (this.details !== void 0) {
+          return { ...base, details: this.details };
+        }
+        return base;
+      }
+      /**
+       * Returns a string representation of the error
+       * Includes correlation ID for easier debugging
+       */
+      toString() {
+        return `${this.name}: ${this.title} [${this.correlationId}]`;
+      }
+    };
+  }
+});
+
+// src/errors/correlation.ts
+function generateCorrelationId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substr(2, 9);
+  return `req_${timestamp}_${random}`;
+}
+function getCurrentCorrelationId() {
+  const stored = correlationStorage.getStore();
+  return stored && stored.trim() ? stored : "unknown";
+}
+var import_node_async_hooks2, correlationStorage;
+var init_correlation = __esm({
+  "src/errors/correlation.ts"() {
+    "use strict";
+    import_node_async_hooks2 = require("async_hooks");
+    correlationStorage = new import_node_async_hooks2.AsyncLocalStorage();
+  }
+});
+
+// src/errors/internal-server-error.ts
+var internal_server_error_exports = {};
+__export(internal_server_error_exports, {
+  InternalServerError: () => InternalServerError
+});
+var InternalServerError;
+var init_internal_server_error = __esm({
+  "src/errors/internal-server-error.ts"() {
+    "use strict";
+    init_errors();
+    init_correlation();
+    InternalServerError = class extends BlaizeError {
+      /**
+       * Creates a new InternalServerError instance
+       *
+       * @param title - Human-readable error message
+       * @param details - Optional debugging context
+       * @param correlationId - Optional correlation ID (uses current context if not provided)
+       */
+      constructor(title, details = void 0, correlationId = void 0) {
+        super(
+          "INTERNAL_SERVER_ERROR" /* INTERNAL_SERVER_ERROR */,
+          title,
+          500,
+          // HTTP 500 Internal Server Error
+          correlationId ?? getCurrentCorrelationId(),
+          details
+        );
+      }
+    };
+  }
+});
+
+// src/errors/validation-error.ts
+var validation_error_exports = {};
+__export(validation_error_exports, {
+  ValidationError: () => ValidationError
+});
+var ValidationError;
+var init_validation_error = __esm({
+  "src/errors/validation-error.ts"() {
+    "use strict";
+    init_errors();
+    init_correlation();
+    ValidationError = class extends BlaizeError {
+      /**
+       * Creates a new ValidationError instance
+       *
+       * @param title - Human-readable error message
+       * @param details - Optional structured validation details
+       * @param correlationId - Optional correlation ID (uses current context if not provided)
+       */
+      constructor(title, details = void 0, correlationId = void 0) {
+        super(
+          "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+          title,
+          400,
+          // HTTP 400 Bad Request
+          correlationId ?? getCurrentCorrelationId(),
+          details
+        );
+      }
+    };
+  }
+});
+
+// src/errors/payload-too-large-error.ts
+var payload_too_large_error_exports = {};
+__export(payload_too_large_error_exports, {
+  PayloadTooLargeError: () => PayloadTooLargeError
+});
+var PayloadTooLargeError;
+var init_payload_too_large_error = __esm({
+  "src/errors/payload-too-large-error.ts"() {
+    "use strict";
+    init_correlation();
+    init_errors();
+    PayloadTooLargeError = class extends BlaizeError {
+      constructor(title, details, correlationId) {
+        super(
+          "PAYLOAD_TOO_LARGE" /* PAYLOAD_TOO_LARGE */,
+          title,
+          413,
+          correlationId ?? getCurrentCorrelationId(),
+          details
+        );
+      }
+    };
+  }
+});
+
+// src/errors/unsupported-media-type-error.ts
+var unsupported_media_type_error_exports = {};
+__export(unsupported_media_type_error_exports, {
+  UnsupportedMediaTypeError: () => UnsupportedMediaTypeError
+});
+var UnsupportedMediaTypeError;
+var init_unsupported_media_type_error = __esm({
+  "src/errors/unsupported-media-type-error.ts"() {
+    "use strict";
+    init_correlation();
+    init_errors();
+    UnsupportedMediaTypeError = class extends BlaizeError {
+      constructor(title, details, correlationId) {
+        super(
+          "UNSUPPORTED_MEDIA_TYPE" /* UNSUPPORTED_MEDIA_TYPE */,
+          title,
+          415,
+          correlationId ?? getCurrentCorrelationId(),
+          details
+        );
+      }
+    };
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
   Blaize: () => Blaize,
+  BlaizeError: () => BlaizeError,
+  ConflictError: () => ConflictError,
+  ErrorSeverity: () => ErrorSeverity,
+  ErrorType: () => ErrorType,
+  ForbiddenError: () => ForbiddenError,
+  InternalServerError: () => InternalServerError,
   MiddlewareAPI: () => MiddlewareAPI,
+  NotFoundError: () => NotFoundError,
   PluginsAPI: () => PluginsAPI,
+  RateLimitError: () => RateLimitError,
   RouterAPI: () => RouterAPI,
   ServerAPI: () => ServerAPI,
+  UnauthorizedError: () => UnauthorizedError,
   VERSION: () => VERSION,
+  ValidationError: () => ValidationError,
   compose: () => compose,
   createDeleteRoute: () => createDeleteRoute,
   createGetRoute: () => createGetRoute,
@@ -55,7 +319,8 @@ __export(index_exports, {
   createPostRoute: () => createPostRoute,
   createPutRoute: () => createPutRoute,
   createServer: () => create3,
-  default: () => index_default
+  default: () => index_default,
+  isBodyParseError: () => isBodyParseError
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -341,7 +606,7 @@ function validateSchema(method, schema) {
 }
 
 // src/server/create.ts
-var import_node_async_hooks2 = require("async_hooks");
+var import_node_async_hooks3 = require("async_hooks");
 var import_node_events = __toESM(require("events"), 1);
 
 // src/server/start.ts
@@ -437,8 +702,474 @@ function runWithContext(context, callback) {
   return contextStorage.run(context, callback);
 }
 
+// src/upload/multipart-parser.ts
+var import_node_crypto = require("crypto");
+var import_node_fs = require("fs");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var import_node_stream = require("stream");
+
+// src/upload/utils.ts
+var BOUNDARY_REGEX = /boundary=([^;]+)/i;
+var CONTENT_DISPOSITION_REGEX = /Content-Disposition:\s*form-data;\s*name="([^"]+)"(?:;[\s\r\n]*filename="([^"]*)")?/i;
+var CONTENT_TYPE_REGEX = /Content-Type:\s*([^\r\n]+)/i;
+var MULTIPART_REGEX = /multipart\/form-data/i;
+function extractBoundary(contentType) {
+  const match = contentType.match(BOUNDARY_REGEX);
+  if (!match || !match[1]) return null;
+  let boundary = match[1].trim();
+  if (boundary.startsWith('"') && boundary.endsWith('"')) {
+    boundary = boundary.slice(1, -1);
+  }
+  return boundary || null;
+}
+function parseContentDisposition(headers) {
+  const match = headers.match(CONTENT_DISPOSITION_REGEX);
+  if (!match || !match[1]) return null;
+  return {
+    name: match[1],
+    filename: match[2] !== void 0 ? match[2] : void 0
+  };
+}
+function parseContentType(headers) {
+  const match = headers.match(CONTENT_TYPE_REGEX);
+  return match && match[1]?.trim() ? match[1].trim() : "application/octet-stream";
+}
+function isMultipartContent(contentType) {
+  return MULTIPART_REGEX.test(contentType);
+}
+
+// src/upload/multipart-parser.ts
+var DEFAULT_OPTIONS = {
+  maxFileSize: 10 * 1024 * 1024,
+  // 10MB
+  maxFiles: 10,
+  maxFieldSize: 1 * 1024 * 1024,
+  // 1MB
+  allowedMimeTypes: [],
+  allowedExtensions: [],
+  strategy: "stream",
+  tempDir: (0, import_node_os.tmpdir)(),
+  computeHash: false
+};
+function createParserState(boundary, options = {}) {
+  return {
+    boundary: Buffer.from(`--${boundary}`),
+    options: { ...DEFAULT_OPTIONS, ...options },
+    fields: /* @__PURE__ */ new Map(),
+    files: /* @__PURE__ */ new Map(),
+    buffer: Buffer.alloc(0),
+    stage: "boundary",
+    currentHeaders: "",
+    currentField: null,
+    currentFilename: void 0,
+    currentMimetype: "application/octet-stream",
+    currentContentLength: 0,
+    fileCount: 0,
+    fieldCount: 0,
+    currentBufferChunks: [],
+    currentStream: null,
+    currentTempPath: null,
+    currentWriteStream: null,
+    streamController: null,
+    cleanupTasks: [],
+    // Track validation state
+    hasFoundValidBoundary: false,
+    hasProcessedAnyPart: false,
+    isFinished: false
+  };
+}
+async function processChunk(state, chunk) {
+  const newBuffer = Buffer.concat([state.buffer, chunk]);
+  let currentState = { ...state, buffer: newBuffer };
+  while (currentState.buffer.length > 0 && !currentState.isFinished) {
+    const nextState = await processCurrentStage(currentState);
+    if (nextState === currentState) break;
+    currentState = nextState;
+  }
+  return currentState;
+}
+async function processCurrentStage(state) {
+  switch (state.stage) {
+    case "boundary":
+      return processBoundary(state);
+    case "headers":
+      return processHeaders(state);
+    case "content":
+      return processContent(state);
+    default: {
+      const { InternalServerError: InternalServerError2 } = await Promise.resolve().then(() => (init_internal_server_error(), internal_server_error_exports));
+      throw new InternalServerError2(`Invalid parser stage`, {
+        operation: state.stage
+      });
+    }
+  }
+}
+function processBoundary(state) {
+  const boundaryIndex = state.buffer.indexOf(state.boundary);
+  if (boundaryIndex === -1) return state;
+  const hasFoundValidBoundary = true;
+  let buffer = state.buffer.subarray(boundaryIndex + state.boundary.length);
+  if (buffer.length >= 2 && buffer.subarray(0, 2).equals(Buffer.from("--"))) {
+    return {
+      ...state,
+      buffer,
+      hasFoundValidBoundary,
+      isFinished: true,
+      stage: "boundary"
+    };
+  }
+  if (buffer.length >= 2 && buffer.subarray(0, 2).equals(Buffer.from("\r\n"))) {
+    buffer = buffer.subarray(2);
+  }
+  return {
+    ...state,
+    buffer,
+    hasFoundValidBoundary,
+    stage: "headers",
+    currentHeaders: ""
+  };
+}
+async function processHeaders(state) {
+  const headerEnd = state.buffer.indexOf("\r\n\r\n");
+  if (headerEnd === -1) return state;
+  const headers = state.buffer.subarray(0, headerEnd).toString("utf8");
+  const buffer = state.buffer.subarray(headerEnd + 4);
+  const disposition = parseContentDisposition(headers);
+  if (!disposition) {
+    const { ValidationError: ValidationError2 } = await Promise.resolve().then(() => (init_validation_error(), validation_error_exports));
+    throw new ValidationError2("Missing or invalid Content-Disposition header");
+  }
+  const mimetype = parseContentType(headers);
+  const isFile = disposition.filename !== void 0;
+  if (isFile && state.fileCount >= state.options.maxFiles) {
+    const { PayloadTooLargeError: PayloadTooLargeError2 } = await Promise.resolve().then(() => (init_payload_too_large_error(), payload_too_large_error_exports));
+    throw new PayloadTooLargeError2("Too many files in upload", {
+      fileCount: state.fileCount + 1,
+      maxFiles: state.options.maxFiles,
+      filename: disposition.filename
+    });
+  }
+  if (isFile && state.options.allowedMimeTypes.length > 0 && !state.options.allowedMimeTypes.includes(mimetype)) {
+    const { UnsupportedMediaTypeError: UnsupportedMediaTypeError2 } = await Promise.resolve().then(() => (init_unsupported_media_type_error(), unsupported_media_type_error_exports));
+    throw new UnsupportedMediaTypeError2("File type not allowed", {
+      receivedMimeType: mimetype,
+      allowedMimeTypes: state.options.allowedMimeTypes,
+      filename: disposition.filename
+    });
+  }
+  return {
+    ...state,
+    buffer,
+    stage: "content",
+    currentHeaders: headers,
+    currentField: disposition.name,
+    currentFilename: disposition.filename,
+    currentMimetype: mimetype,
+    currentContentLength: 0,
+    fileCount: isFile ? state.fileCount + 1 : state.fileCount,
+    fieldCount: isFile ? state.fieldCount : state.fieldCount + 1,
+    currentBufferChunks: []
+  };
+}
+async function processContent(state) {
+  const nextBoundaryIndex = state.buffer.indexOf(state.boundary);
+  let contentChunk;
+  let isComplete = false;
+  let buffer = state.buffer;
+  if (nextBoundaryIndex === -1) {
+    const safeLength = Math.max(0, state.buffer.length - state.boundary.length);
+    if (safeLength === 0) return state;
+    contentChunk = state.buffer.subarray(0, safeLength);
+    buffer = state.buffer.subarray(safeLength);
+  } else {
+    const contentEnd = Math.max(0, nextBoundaryIndex - 2);
+    contentChunk = state.buffer.subarray(0, contentEnd);
+    buffer = state.buffer.subarray(nextBoundaryIndex);
+    isComplete = true;
+  }
+  let updatedState = { ...state, buffer };
+  if (contentChunk.length > 0) {
+    updatedState = await processContentChunk(updatedState, contentChunk);
+  }
+  if (isComplete) {
+    updatedState = await finalizeCurrentPart(updatedState);
+    updatedState = {
+      ...updatedState,
+      stage: "boundary",
+      hasProcessedAnyPart: true
+      // Mark that we've processed at least one part
+    };
+  }
+  return updatedState;
+}
+async function processContentChunk(state, chunk) {
+  const newContentLength = state.currentContentLength + chunk.length;
+  const maxSize = state.currentFilename !== void 0 ? state.options.maxFileSize : state.options.maxFieldSize;
+  if (newContentLength > maxSize) {
+    const isFile = state.currentFilename !== void 0;
+    const { PayloadTooLargeError: PayloadTooLargeError2 } = await Promise.resolve().then(() => (init_payload_too_large_error(), payload_too_large_error_exports));
+    const payloadErrorDetals = state.currentField ? {
+      contentType: isFile ? "file" : "field",
+      currentSize: newContentLength,
+      maxSize,
+      field: state.currentField,
+      filename: state.currentFilename
+    } : {
+      contentType: isFile ? "file" : "field",
+      currentSize: newContentLength,
+      maxSize,
+      filename: state.currentFilename
+    };
+    throw new PayloadTooLargeError2(
+      `${isFile ? "File" : "Field"} size exceeds limit`,
+      payloadErrorDetals
+    );
+  }
+  if (state.currentFilename !== void 0) {
+    return processFileChunk(state, chunk, newContentLength);
+  } else {
+    return {
+      ...state,
+      currentContentLength: newContentLength,
+      currentBufferChunks: [...state.currentBufferChunks, chunk]
+    };
+  }
+}
+async function processFileChunk(state, chunk, newContentLength) {
+  switch (state.options.strategy) {
+    case "memory":
+      return {
+        ...state,
+        currentContentLength: newContentLength,
+        currentBufferChunks: [...state.currentBufferChunks, chunk]
+      };
+    case "stream":
+      if (state.streamController) {
+        state.streamController.enqueue(chunk);
+      }
+      return { ...state, currentContentLength: newContentLength };
+    case "temp":
+      if (state.currentWriteStream) {
+        await writeToStream(state.currentWriteStream, chunk);
+      }
+      return { ...state, currentContentLength: newContentLength };
+    default: {
+      const { ValidationError: ValidationError2 } = await Promise.resolve().then(() => (init_validation_error(), validation_error_exports));
+      throw new ValidationError2(`Invalid parsing strategy`);
+    }
+  }
+}
+async function initializeFileProcessing(state) {
+  if (state.currentFilename === void 0) return state;
+  switch (state.options.strategy) {
+    case "memory":
+      return { ...state, currentBufferChunks: [] };
+    case "stream": {
+      let streamController = null;
+      const stream = new ReadableStream({
+        start: (controller) => {
+          streamController = controller;
+        }
+      });
+      return {
+        ...state,
+        currentStream: stream,
+        // Type cast for Node.js compatibility
+        streamController
+      };
+    }
+    case "temp": {
+      const tempPath = (0, import_node_path.join)(state.options.tempDir, `upload-${(0, import_node_crypto.randomUUID)()}`);
+      const writeStream = (0, import_node_fs.createWriteStream)(tempPath);
+      const cleanupTask = async () => {
+        try {
+          const { unlink } = await import("fs/promises");
+          await unlink(tempPath);
+        } catch (error) {
+          console.warn(`Failed to cleanup temp file: ${tempPath}`, error);
+        }
+      };
+      return {
+        ...state,
+        currentTempPath: tempPath,
+        currentWriteStream: writeStream,
+        cleanupTasks: [...state.cleanupTasks, cleanupTask]
+      };
+    }
+    default: {
+      const { ValidationError: ValidationError2 } = await Promise.resolve().then(() => (init_validation_error(), validation_error_exports));
+      throw new ValidationError2(`Invalid file processing strategy`);
+    }
+  }
+}
+async function finalizeCurrentPart(state) {
+  if (!state.currentField) return resetCurrentPart(state);
+  if (state.currentFilename !== void 0) {
+    return finalizeFile(state);
+  } else {
+    return finalizeField(state);
+  }
+}
+async function finalizeFile(state) {
+  if (!state.currentField || state.currentFilename === void 0) {
+    return resetCurrentPart(state);
+  }
+  let stream;
+  let buffer;
+  let tempPath;
+  switch (state.options.strategy) {
+    case "memory":
+      buffer = Buffer.concat(state.currentBufferChunks);
+      stream = import_node_stream.Readable.from(buffer);
+      break;
+    case "stream":
+      if (state.streamController) {
+        state.streamController.close();
+      }
+      stream = state.currentStream;
+      break;
+    case "temp":
+      if (state.currentWriteStream) {
+        await closeStream(state.currentWriteStream);
+      }
+      tempPath = state.currentTempPath;
+      stream = import_node_stream.Readable.from(Buffer.alloc(0));
+      break;
+    default: {
+      const { ValidationError: ValidationError2 } = await Promise.resolve().then(() => (init_validation_error(), validation_error_exports));
+      throw new ValidationError2(`Invalid file finalization strategy`);
+    }
+  }
+  const file = {
+    filename: state.currentFilename,
+    fieldname: state.currentField,
+    mimetype: state.currentMimetype,
+    size: state.currentContentLength,
+    stream,
+    buffer,
+    tempPath
+  };
+  const updatedFiles = addToCollection(state.files, state.currentField, file);
+  return {
+    ...resetCurrentPart(state),
+    files: updatedFiles
+  };
+}
+function finalizeField(state) {
+  if (!state.currentField) return resetCurrentPart(state);
+  const value = Buffer.concat(state.currentBufferChunks).toString("utf8");
+  const updatedFields = addToCollection(state.fields, state.currentField, value);
+  return {
+    ...resetCurrentPart(state),
+    fields: updatedFields
+  };
+}
+function resetCurrentPart(state) {
+  return {
+    ...state,
+    currentField: null,
+    currentFilename: void 0,
+    currentContentLength: 0,
+    currentBufferChunks: [],
+    currentStream: null,
+    streamController: null,
+    currentTempPath: null,
+    currentWriteStream: null
+  };
+}
+function addToCollection(collection, key, value) {
+  const newCollection = new Map(collection);
+  const existing = newCollection.get(key) || [];
+  newCollection.set(key, [...existing, value]);
+  return newCollection;
+}
+async function finalize(state) {
+  if (!state.hasFoundValidBoundary) {
+    const { ValidationError: ValidationError2 } = await Promise.resolve().then(() => (init_validation_error(), validation_error_exports));
+    throw new ValidationError2("No valid multipart boundary found");
+  }
+  if (state.hasFoundValidBoundary && !state.hasProcessedAnyPart) {
+    const { ValidationError: ValidationError2 } = await Promise.resolve().then(() => (init_validation_error(), validation_error_exports));
+    throw new ValidationError2("Empty multipart request");
+  }
+  const fields = {};
+  for (const [key, values] of state.fields.entries()) {
+    fields[key] = values.length === 1 ? values[0] : values;
+  }
+  const files = {};
+  for (const [key, fileList] of state.files.entries()) {
+    files[key] = fileList.length === 1 ? fileList[0] : fileList;
+  }
+  return { fields, files };
+}
+async function cleanup(state) {
+  await Promise.allSettled(state.cleanupTasks.map((task) => task()));
+  if (state.streamController) {
+    state.streamController.close();
+  }
+  if (state.currentWriteStream) {
+    await closeStream(state.currentWriteStream);
+  }
+}
+async function writeToStream(stream, chunk) {
+  return new Promise((resolve3, reject) => {
+    stream.write(chunk, (error) => {
+      if (error) reject(error);
+      else resolve3();
+    });
+  });
+}
+async function closeStream(stream) {
+  return new Promise((resolve3) => {
+    stream.end(() => resolve3());
+  });
+}
+async function parseMultipartRequest(request, options = {}) {
+  const contentType = request.headers["content-type"] || "";
+  const boundary = extractBoundary(contentType);
+  if (!boundary) {
+    const { UnsupportedMediaTypeError: UnsupportedMediaTypeError2 } = await Promise.resolve().then(() => (init_unsupported_media_type_error(), unsupported_media_type_error_exports));
+    throw new UnsupportedMediaTypeError2("Missing boundary in multipart content-type", {
+      receivedContentType: contentType,
+      expectedFormat: "multipart/form-data; boundary=..."
+    });
+  }
+  let state = createParserState(boundary, options);
+  if (state.currentFilename !== void 0) {
+    state = await initializeFileProcessing(state);
+  }
+  try {
+    for await (const chunk of request) {
+      state = await processChunk(state, chunk);
+    }
+    return finalize(state);
+  } finally {
+    await cleanup(state);
+  }
+}
+
 // src/context/create.ts
 var CONTENT_TYPE_HEADER = "Content-Type";
+var DEFAULT_BODY_LIMITS = {
+  json: 512 * 1024,
+  // 512KB - Most APIs should be much smaller
+  form: 1024 * 1024,
+  // 1MB - Reasonable for form submissions
+  text: 5 * 1024 * 1024,
+  // 5MB - Documents, logs, code files
+  multipart: {
+    maxFileSize: 50 * 1024 * 1024,
+    // 50MB per file
+    maxTotalSize: 100 * 1024 * 1024,
+    // 100MB total request
+    maxFiles: 10,
+    maxFieldSize: 1024 * 1024
+    // 1MB for form fields
+  },
+  raw: 10 * 1024 * 1024
+  // 10MB for unknown content types
+};
 function parseRequestUrl(req) {
   const originalUrl = req.url || "/";
   const host = req.headers.host || "localhost";
@@ -503,7 +1234,7 @@ async function createContext(req, res, options = {}) {
   };
   ctx.response = createResponseObject(res, responseState, ctx);
   if (options.parseBody) {
-    await parseBodyIfNeeded(req, ctx);
+    await parseBodyIfNeeded(req, ctx, options);
   }
   return ctx;
 }
@@ -679,34 +1410,60 @@ function createStreamResponder(res, responseState) {
     });
   };
 }
-async function parseBodyIfNeeded(req, ctx) {
+async function parseBodyIfNeeded(req, ctx, options = {}) {
   if (shouldSkipParsing(req.method)) {
     return;
   }
   const contentType = req.headers["content-type"] || "";
   const contentLength = parseInt(req.headers["content-length"] || "0", 10);
-  if (contentLength === 0 || contentLength > 1048576) {
+  if (contentLength === 0) {
     return;
   }
+  const limits = {
+    json: options.bodyLimits?.json ?? DEFAULT_BODY_LIMITS.json,
+    form: options.bodyLimits?.form ?? DEFAULT_BODY_LIMITS.form,
+    text: options.bodyLimits?.text ?? DEFAULT_BODY_LIMITS.text,
+    raw: options.bodyLimits?.raw ?? DEFAULT_BODY_LIMITS.raw,
+    multipart: {
+      maxFileSize: options.bodyLimits?.multipart?.maxFileSize ?? DEFAULT_BODY_LIMITS.multipart.maxFileSize,
+      maxFiles: options.bodyLimits?.multipart?.maxFiles ?? DEFAULT_BODY_LIMITS.multipart.maxFiles,
+      maxFieldSize: options.bodyLimits?.multipart?.maxFieldSize ?? DEFAULT_BODY_LIMITS.multipart.maxFieldSize,
+      maxTotalSize: options.bodyLimits?.multipart?.maxTotalSize ?? DEFAULT_BODY_LIMITS.multipart.maxTotalSize
+    }
+  };
   try {
-    await parseBodyByContentType(req, ctx, contentType);
+    if (contentType.includes("application/json")) {
+      if (contentLength > limits.json) {
+        throw new Error(`JSON body too large: ${contentLength} > ${limits.json} bytes`);
+      }
+      await parseJsonBody(req, ctx);
+    } else if (contentType.includes("application/x-www-form-urlencoded")) {
+      if (contentLength > limits.form) {
+        throw new Error(`Form body too large: ${contentLength} > ${limits.form} bytes`);
+      }
+      await parseFormUrlEncodedBody(req, ctx);
+    } else if (contentType.includes("text/")) {
+      if (contentLength > limits.text) {
+        throw new Error(`Text body too large: ${contentLength} > ${limits.text} bytes`);
+      }
+      await parseTextBody(req, ctx);
+    } else if (isMultipartContent(contentType)) {
+      await parseMultipartBody(req, ctx, limits.multipart);
+    } else {
+      if (contentLength > limits.raw) {
+        throw new Error(`Request body too large: ${contentLength} > ${limits.raw} bytes`);
+      }
+      return;
+    }
   } catch (error) {
-    setBodyError(ctx, "body_read_error", "Error reading request body", error);
+    const errorType = contentType.includes("multipart") ? "multipart_parse_error" : "body_read_error";
+    setBodyError(ctx, errorType, "Error reading request body", error);
   }
 }
 function shouldSkipParsing(method) {
   const skipMethods = ["GET", "HEAD", "OPTIONS"];
   return skipMethods.includes(method || "GET");
 }
-async function parseBodyByContentType(req, ctx, contentType) {
-  if (contentType.includes("application/json")) {
-    await parseJsonBody(req, ctx);
-  } else if (contentType.includes("application/x-www-form-urlencoded")) {
-    await parseFormUrlEncodedBody(req, ctx);
-  } else if (contentType.includes("text/")) {
-    await parseTextBody(req, ctx);
-  }
-}
 async function parseJsonBody(req, ctx) {
   const body = await readRequestBody(req);
   if (!body) {
@@ -758,8 +1515,27 @@ async function parseTextBody(req, ctx) {
     ctx.request.body = body;
   }
 }
+async function parseMultipartBody(req, ctx, multipartLimits) {
+  try {
+    const limits = multipartLimits || DEFAULT_BODY_LIMITS.multipart;
+    const multipartData = await parseMultipartRequest(req, {
+      strategy: "stream",
+      maxFileSize: limits.maxFileSize,
+      maxFiles: limits.maxFiles,
+      maxFieldSize: limits.maxFieldSize
+      // Could add total size validation here
+    });
+    ctx.request.multipart = multipartData;
+    ctx.request.files = multipartData.files;
+    ctx.request.body = multipartData.fields;
+  } catch (error) {
+    ctx.request.body = null;
+    setBodyError(ctx, "multipart_parse_error", "Failed to parse multipart data", error);
+  }
+}
 function setBodyError(ctx, type, message, error) {
-  ctx.state._bodyError = { type, message, error };
+  const bodyError = { type, message, error };
+  ctx.state._bodyError = bodyError;
 }
 async function readRequestBody(req) {
   return new Promise((resolve3, reject) => {
@@ -776,6 +1552,107 @@ async function readRequestBody(req) {
   });
 }
 
+// src/errors/not-found-error.ts
+init_errors();
+init_correlation();
+var NotFoundError = class extends BlaizeError {
+  /**
+   * Creates a new NotFoundError instance
+   *
+   * @param title - Human-readable error message
+   * @param details - Optional context about the missing resource
+   * @param correlationId - Optional correlation ID (uses current context if not provided)
+   */
+  constructor(title, details = void 0, correlationId = void 0) {
+    super(
+      "NOT_FOUND" /* NOT_FOUND */,
+      title,
+      404,
+      // HTTP 404 Not Found
+      correlationId ?? getCurrentCorrelationId(),
+      details
+    );
+  }
+};
+
+// src/errors/boundary.ts
+init_errors();
+init_correlation();
+init_internal_server_error();
+function isHandledError(error) {
+  return error instanceof BlaizeError;
+}
+function formatErrorResponse(error) {
+  if (isHandledError(error)) {
+    return {
+      type: error.type,
+      title: error.title,
+      status: error.status,
+      correlationId: error.correlationId,
+      timestamp: error.timestamp.toISOString(),
+      details: error.details
+    };
+  }
+  const correlationId = generateCorrelationId();
+  let originalMessage;
+  if (error instanceof Error) {
+    originalMessage = error.message;
+  } else if (error === null || error === void 0) {
+    originalMessage = "Unknown error occurred";
+  } else {
+    originalMessage = String(error);
+  }
+  const wrappedError = new InternalServerError(
+    "Internal Server Error",
+    { originalMessage },
+    correlationId
+  );
+  return {
+    type: wrappedError.type,
+    title: wrappedError.title,
+    status: wrappedError.status,
+    correlationId: wrappedError.correlationId,
+    timestamp: wrappedError.timestamp.toISOString(),
+    details: wrappedError.details
+  };
+}
+function extractOrGenerateCorrelationId(headerGetter) {
+  return headerGetter("x-correlation-id") ?? generateCorrelationId();
+}
+function setErrorResponseHeaders(headerSetter, correlationId) {
+  headerSetter("x-correlation-id", correlationId);
+}
+
+// src/middleware/error-boundary.ts
+function createErrorBoundary(options = {}) {
+  const { debug = false } = options;
+  const middlewareFn = async (ctx, next) => {
+    try {
+      await next();
+    } catch (error) {
+      if (ctx.response.sent) {
+        if (debug) {
+          console.error("Error occurred after response was sent:", error);
+        }
+        return;
+      }
+      if (debug) {
+        console.error("Error boundary caught error:", error);
+      }
+      const correlationId = extractOrGenerateCorrelationId(ctx.request.header);
+      const errorResponse = formatErrorResponse(error);
+      errorResponse.correlationId = correlationId;
+      setErrorResponseHeaders(ctx.response.header, correlationId);
+      ctx.response.status(errorResponse.status).json(errorResponse);
+    }
+  };
+  return {
+    name: "ErrorBoundary",
+    execute: middlewareFn,
+    debug
+  };
+}
+
 // src/server/request-handler.ts
 function createRequestHandler(serverInstance) {
   return async (req, res) => {
@@ -784,32 +1661,20 @@ function createRequestHandler(serverInstance) {
         parseBody: true
         // Enable automatic body parsing
       });
-      const handler = compose(serverInstance.middleware);
+      const errorBoundary = createErrorBoundary();
+      const allMiddleware = [errorBoundary, ...serverInstance.middleware];
+      const handler = compose(allMiddleware);
       await runWithContext(context, async () => {
-        try {
-          await handler(context, async () => {
+        await handler(context, async () => {
+          if (!context.response.sent) {
+            await serverInstance.router.handleRequest(context);
             if (!context.response.sent) {
-              await serverInstance.router.handleRequest(context);
-              if (!context.response.sent) {
-                context.response.status(404).json({
-                  error: "Not Found",
-                  message: `Route not found: ${context.request.method} ${context.request.path}`
-                });
-              }
+              throw new NotFoundError(
+                `Route not found: ${context.request.method} ${context.request.path}`
+              );
             }
-          });
-        } catch (error) {
-          console.error("Error processing request:", error);
-          if (!context.response.sent) {
-            context.response.json(
-              {
-                error: "Internal Server Error",
-                message: process.env.NODE_ENV === "development" ? error || "Unknown error" : "An error occurred processing your request"
-              },
-              500
-            );
           }
-        }
+        });
       });
     } catch (error) {
       console.error("Error creating context:", error);
@@ -1651,81 +2516,8 @@ function watchRoutes(routesDir, options = {}) {
   };
 }
 
-// src/router/handlers/error.ts
-function handleRouteError(ctx, error, options = {}) {
-  if (options.log) {
-    console.error("Route error:", error);
-  }
-  const status = getErrorStatus(error);
-  const response = {
-    error: getErrorType(error),
-    message: getErrorMessage(error)
-  };
-  if (options.detailed) {
-    if (error instanceof Error) {
-      response.stack = error.stack;
-    }
-    if (error && typeof error === "object" && "details" in error && error.details) {
-      response.details = error.details;
-    }
-  }
-  ctx.response.status(status).json(response);
-}
-function getErrorStatus(error) {
-  if (error && typeof error === "object") {
-    if ("status" in error && typeof error.status === "number") {
-      return error.status;
-    }
-    if ("statusCode" in error && typeof error.statusCode === "number") {
-      return error.statusCode;
-    }
-    if ("code" in error && typeof error.code === "string") {
-      return getStatusFromCode(error.code);
-    }
-  }
-  return 500;
-}
-function getStatusFromCode(code) {
-  switch (code) {
-    case "NOT_FOUND":
-      return 404;
-    case "UNAUTHORIZED":
-      return 401;
-    case "FORBIDDEN":
-      return 403;
-    case "BAD_REQUEST":
-      return 400;
-    case "CONFLICT":
-      return 409;
-    default:
-      return 500;
-  }
-}
-function getErrorType(error) {
-  if (error && typeof error === "object") {
-    if ("type" in error && typeof error.type === "string") {
-      return error.type;
-    }
-    if ("name" in error && typeof error.name === "string") {
-      return error.name;
-    }
-    if (error instanceof Error) {
-      return error.constructor.name;
-    }
-  }
-  return "Error";
-}
-function getErrorMessage(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  if (error && typeof error === "object") {
-    if ("message" in error && typeof error.message === "string") {
-      return error.message;
-    }
-  }
-  return String(error);
-}
+// src/router/validation/schema.ts
+var import_zod6 = require("zod");
 
 // src/router/validation/body.ts
 var import_zod2 = require("zod");
@@ -1764,37 +2556,49 @@ function validateResponse(response, schema) {
 }
 
 // src/router/validation/schema.ts
+init_internal_server_error();
+init_validation_error();
 function createRequestValidator(schema, debug = false) {
   const middlewareFn = async (ctx, next) => {
-    const errors = {};
     if (schema.params && ctx.request.params) {
       try {
         ctx.request.params = validateParams(ctx.request.params, schema.params);
       } catch (error) {
-        errors.params = formatValidationError(error);
+        const fieldErrors = extractZodFieldErrors(error);
+        const errorCount = fieldErrors.reduce((sum, fe) => sum + fe.messages.length, 0);
+        throw new ValidationError("Request validation failed", {
+          fields: fieldErrors,
+          errorCount,
+          section: "params"
+        });
       }
     }
     if (schema.query && ctx.request.query) {
       try {
         ctx.request.query = validateQuery(ctx.request.query, schema.query);
       } catch (error) {
-        errors.query = formatValidationError(error);
+        const fieldErrors = extractZodFieldErrors(error);
+        const errorCount = fieldErrors.reduce((sum, fe) => sum + fe.messages.length, 0);
+        throw new ValidationError("Request validation failed", {
+          fields: fieldErrors,
+          errorCount,
+          section: "query"
+        });
       }
     }
     if (schema.body) {
       try {
         ctx.request.body = validateBody(ctx.request.body, schema.body);
       } catch (error) {
-        errors.body = formatValidationError(error);
+        const fieldErrors = extractZodFieldErrors(error);
+        const errorCount = fieldErrors.reduce((sum, fe) => sum + fe.messages.length, 0);
+        throw new ValidationError("Request validation failed", {
+          fields: fieldErrors,
+          errorCount,
+          section: "body"
+        });
       }
     }
-    if (Object.keys(errors).length > 0) {
-      ctx.response.status(400).json({
-        error: "Validation Error",
-        details: errors
-      });
-      return;
-    }
     await next();
   };
   return {
@@ -1813,12 +2617,11 @@ function createResponseValidator(responseSchema, debug = false) {
         return originalJson.call(ctx.response, validatedBody, status);
       } catch (error) {
         ctx.response.json = originalJson;
-        console.error("Response validation error:", error);
-        ctx.response.status(500).json({
-          error: "Internal Server Error",
-          message: "Response validation failed"
+        throw new InternalServerError("Response validation failed", {
+          responseSchema: responseSchema.description || "Unknown schema",
+          validationError: extractZodFieldErrors(error),
+          originalResponse: body
         });
-        return ctx.response;
       }
     };
     await next();
@@ -1829,11 +2632,25 @@ function createResponseValidator(responseSchema, debug = false) {
     debug
   };
 }
-function formatValidationError(error) {
-  if (error && typeof error === "object" && "format" in error && typeof error.format === "function") {
-    return error.format();
+function extractZodFieldErrors(error) {
+  if (error instanceof import_zod6.z.ZodError) {
+    const fieldErrorMap = /* @__PURE__ */ new Map();
+    for (const issue of error.issues) {
+      const fieldPath = issue.path.length > 0 ? issue.path.join(".") : "root";
+      if (!fieldErrorMap.has(fieldPath)) {
+        fieldErrorMap.set(fieldPath, []);
+      }
+      fieldErrorMap.get(fieldPath).push(issue.message);
+    }
+    return Array.from(fieldErrorMap.entries()).map(([field, messages]) => ({
+      field,
+      messages
+    }));
+  }
+  if (error instanceof Error) {
+    return [{ field: "unknown", messages: [error.message] }];
   }
-  return error instanceof Error ? error.message : String(error);
+  return [{ field: "unknown", messages: [String(error)] }];
 }
 
 // src/router/handlers/executor.ts
@@ -2268,8 +3085,7 @@ function createRouter(options) {
       const match = matcher.match(path6, method);
       if (!match) {
         console.log(`\u274C No match found for: ${method} ${path6}`);
-        ctx.response.status(404).json({ error: "Not Found" });
-        return;
+        throw new NotFoundError("Not found");
       }
       console.log(`\u2705 Route matched: ${method} ${path6}`);
       console.log(`   Params: ${JSON.stringify(match.params)}`);
@@ -2284,14 +3100,7 @@ function createRouter(options) {
         return;
       }
       ctx.request.params = match.params;
-      try {
-        await executeHandler(ctx, match.route, match.params);
-      } catch (error) {
-        handleRouteError(ctx, error, {
-          detailed: process.env.NODE_ENV !== "production",
-          log: true
-        });
-      }
+      await executeHandler(ctx, match.route, match.params);
     },
     /**
      * Get all registered routes (using optimized registry)
@@ -2352,7 +3161,7 @@ function createRouter(options) {
 }
 
 // src/server/create.ts
-var DEFAULT_OPTIONS = {
+var DEFAULT_OPTIONS2 = {
   port: 3e3,
   host: "localhost",
   routesDir: "./routes",
@@ -2363,7 +3172,7 @@ var DEFAULT_OPTIONS = {
   plugins: []
 };
 function createServerOptions(options = {}) {
-  const baseOptions = { ...DEFAULT_OPTIONS };
+  const baseOptions = { ...DEFAULT_OPTIONS2 };
   setRuntimeConfig({ routesDir: options.routesDir || baseOptions.routesDir });
   return {
     port: options.port ?? baseOptions.port,
@@ -2443,7 +3252,7 @@ function create3(options = {}) {
   const { port, host, middleware, plugins } = validatedOptions;
   const initialMiddleware = Array.isArray(middleware) ? [...middleware] : [];
   const initialPlugins = Array.isArray(plugins) ? [...plugins] : [];
-  const contextStorage2 = new import_node_async_hooks2.AsyncLocalStorage();
+  const contextStorage2 = new import_node_async_hooks3.AsyncLocalStorage();
   const router = createRouter({
     routesDir: validatedOptions.routesDir,
     watchMode: process.env.NODE_ENV === "development"
@@ -2483,7 +3292,106 @@ function create3(options = {}) {
   return serverInstance;
 }
 
+// ../blaize-types/src/index.ts
+init_errors();
+
+// src/index.ts
+init_validation_error();
+
+// src/errors/unauthorized-error.ts
+init_errors();
+init_correlation();
+var UnauthorizedError = class extends BlaizeError {
+  /**
+   * Creates a new UnauthorizedError instance
+   *
+   * @param title - Human-readable error message
+   * @param details - Optional authentication context
+   * @param correlationId - Optional correlation ID (uses current context if not provided)
+   */
+  constructor(title, details = void 0, correlationId = void 0) {
+    super(
+      "UNAUTHORIZED" /* UNAUTHORIZED */,
+      title,
+      401,
+      // HTTP 401 Unauthorized
+      correlationId ?? getCurrentCorrelationId(),
+      details
+    );
+  }
+};
+
+// src/errors/forbidden-error.ts
+init_errors();
+init_correlation();
+var ForbiddenError = class extends BlaizeError {
+  /**
+   * Creates a new ForbiddenError instance
+   *
+   * @param title - Human-readable error message
+   * @param details - Optional permission context
+   * @param correlationId - Optional correlation ID (uses current context if not provided)
+   */
+  constructor(title, details = void 0, correlationId = void 0) {
+    super(
+      "FORBIDDEN" /* FORBIDDEN */,
+      title,
+      403,
+      // HTTP 403 Forbidden
+      correlationId ?? getCurrentCorrelationId(),
+      details
+    );
+  }
+};
+
+// src/errors/conflict-error.ts
+init_errors();
+init_correlation();
+var ConflictError = class extends BlaizeError {
+  /**
+   * Creates a new ConflictError instance
+   *
+   * @param title - Human-readable error message
+   * @param details - Optional conflict context
+   * @param correlationId - Optional correlation ID (uses current context if not provided)
+   */
+  constructor(title, details = void 0, correlationId = void 0) {
+    super(
+      "CONFLICT" /* CONFLICT */,
+      title,
+      409,
+      // HTTP 409 Conflict
+      correlationId ?? getCurrentCorrelationId(),
+      details
+    );
+  }
+};
+
+// src/errors/rate-limit-error.ts
+init_errors();
+init_correlation();
+var RateLimitError = class extends BlaizeError {
+  /**
+   * Creates a new RateLimitError instance
+   *
+   * @param title - Human-readable error message
+   * @param details - Optional rate limit context
+   * @param correlationId - Optional correlation ID (uses current context if not provided)
+   */
+  constructor(title, details = void 0, correlationId = void 0) {
+    super(
+      "RATE_LIMITED" /* RATE_LIMITED */,
+      title,
+      429,
+      // HTTP 429 Too Many Requests
+      correlationId ?? getCurrentCorrelationId(),
+      details
+    );
+  }
+};
+
 // src/index.ts
+init_internal_server_error();
 var VERSION = "0.1.0";
 var ServerAPI = { createServer: create3 };
 var RouterAPI = {
@@ -2514,11 +3422,21 @@ var index_default = Blaize;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Blaize,
+  BlaizeError,
+  ConflictError,
+  ErrorSeverity,
+  ErrorType,
+  ForbiddenError,
+  InternalServerError,
   MiddlewareAPI,
+  NotFoundError,
   PluginsAPI,
+  RateLimitError,
   RouterAPI,
   ServerAPI,
+  UnauthorizedError,
   VERSION,
+  ValidationError,
   compose,
   createDeleteRoute,
   createGetRoute,
@@ -2529,6 +3447,7 @@ var index_default = Blaize;
   createPlugin,
   createPostRoute,
   createPutRoute,
-  createServer
+  createServer,
+  isBodyParseError
 });
 //# sourceMappingURL=index.cjs.map