@zudojs/http 0.1.0 → 1.1.0

package/dist/httpStatus/httpStatusCodes.constant.js

@@ -0,0 +1,232 @@
+/**
+ * Standard HTTP status code definitions.
+ *
+ * Kept separate from status.ts so consumers that only need numeric
+ * constants do not have to depend on the status helper implementations.
+ */
+/* -------------------------------------------------------------------------- */
+/* 1xx Informational                                                          */
+/* -------------------------------------------------------------------------- */
+export const CONTINUE = 100;
+export const SWITCHING_PROTOCOLS = 101;
+export const PROCESSING = 102;
+export const EARLY_HINTS = 103;
+/* -------------------------------------------------------------------------- */
+/* 2xx Success                                                                */
+/* -------------------------------------------------------------------------- */
+export const OK = 200;
+export const CREATED = 201;
+export const ACCEPTED = 202;
+export const NON_AUTHORITATIVE_INFORMATION = 203;
+export const NO_CONTENT = 204;
+export const RESET_CONTENT = 205;
+export const PARTIAL_CONTENT = 206;
+export const MULTI_STATUS = 207;
+export const ALREADY_REPORTED = 208;
+export const IM_USED = 226;
+/* -------------------------------------------------------------------------- */
+/* 3xx Redirection                                                            */
+/* -------------------------------------------------------------------------- */
+export const MULTIPLE_CHOICES = 300;
+export const MOVED_PERMANENTLY = 301;
+export const FOUND = 302;
+export const SEE_OTHER = 303;
+export const NOT_MODIFIED = 304;
+export const USE_PROXY = 305;
+export const TEMPORARY_REDIRECT = 307;
+export const PERMANENT_REDIRECT = 308;
+/* -------------------------------------------------------------------------- */
+/* 4xx Client Errors                                                          */
+/* -------------------------------------------------------------------------- */
+export const BAD_REQUEST = 400;
+export const UNAUTHORIZED = 401;
+export const PAYMENT_REQUIRED = 402;
+export const FORBIDDEN = 403;
+export const NOT_FOUND = 404;
+export const METHOD_NOT_ALLOWED = 405;
+export const NOT_ACCEPTABLE = 406;
+export const PROXY_AUTHENTICATION_REQUIRED = 407;
+export const REQUEST_TIMEOUT = 408;
+export const CONFLICT = 409;
+export const GONE = 410;
+export const LENGTH_REQUIRED = 411;
+export const PRECONDITION_FAILED = 412;
+/**
+ * RFC 9110 renamed 413 from "Payload Too Large" to
+ * "Content Too Large". The numeric code remains 413.
+ */
+export const CONTENT_TOO_LARGE = 413;
+/**
+ * Backwards-compatible alias.
+ */
+export const PAYLOAD_TOO_LARGE = CONTENT_TOO_LARGE;
+export const URI_TOO_LONG = 414;
+export const UNSUPPORTED_MEDIA_TYPE = 415;
+export const RANGE_NOT_SATISFIABLE = 416;
+export const EXPECTATION_FAILED = 417;
+export const IM_A_TEAPOT = 418;
+export const MISDIRECTED_REQUEST = 421;
+/**
+ * RFC 9110 renamed 422 from "Unprocessable Entity" to
+ * "Unprocessable Content".
+ */
+export const UNPROCESSABLE_CONTENT = 422;
+/**
+ * Backwards-compatible alias.
+ */
+export const UNPROCESSABLE_ENTITY = UNPROCESSABLE_CONTENT;
+export const LOCKED = 423;
+export const FAILED_DEPENDENCY = 424;
+export const TOO_EARLY = 425;
+export const UPGRADE_REQUIRED = 426;
+export const PRECONDITION_REQUIRED = 428;
+export const TOO_MANY_REQUESTS = 429;
+export const REQUEST_HEADER_FIELDS_TOO_LARGE = 431;
+export const UNAVAILABLE_FOR_LEGAL_REASONS = 451;
+/* -------------------------------------------------------------------------- */
+/* 5xx Server Errors                                                          */
+/* -------------------------------------------------------------------------- */
+export const INTERNAL_SERVER_ERROR = 500;
+export const NOT_IMPLEMENTED = 501;
+export const BAD_GATEWAY = 502;
+export const SERVICE_UNAVAILABLE = 503;
+export const GATEWAY_TIMEOUT = 504;
+export const HTTP_VERSION_NOT_SUPPORTED = 505;
+export const VARIANT_ALSO_NEGOTIATES = 506;
+export const INSUFFICIENT_STORAGE = 507;
+export const LOOP_DETECTED = 508;
+export const NOT_EXTENDED = 510;
+export const NETWORK_AUTHENTICATION_REQUIRED = 511;
+/* -------------------------------------------------------------------------- */
+/* Grouped Constants                                                          */
+/* -------------------------------------------------------------------------- */
+export const INFORMATIONAL_STATUS_CODES = {
+    CONTINUE,
+    SWITCHING_PROTOCOLS,
+    PROCESSING,
+    EARLY_HINTS,
+};
+export const SUCCESS_STATUS_CODES = {
+    OK,
+    CREATED,
+    ACCEPTED,
+    NON_AUTHORITATIVE_INFORMATION,
+    NO_CONTENT,
+    RESET_CONTENT,
+    PARTIAL_CONTENT,
+    MULTI_STATUS,
+    ALREADY_REPORTED,
+    IM_USED,
+};
+export const REDIRECTION_STATUS_CODES = {
+    MULTIPLE_CHOICES,
+    MOVED_PERMANENTLY,
+    FOUND,
+    SEE_OTHER,
+    NOT_MODIFIED,
+    USE_PROXY,
+    TEMPORARY_REDIRECT,
+    PERMANENT_REDIRECT,
+};
+export const CLIENT_ERROR_STATUS_CODES = {
+    BAD_REQUEST,
+    UNAUTHORIZED,
+    PAYMENT_REQUIRED,
+    FORBIDDEN,
+    NOT_FOUND,
+    METHOD_NOT_ALLOWED,
+    NOT_ACCEPTABLE,
+    PROXY_AUTHENTICATION_REQUIRED,
+    REQUEST_TIMEOUT,
+    CONFLICT,
+    GONE,
+    LENGTH_REQUIRED,
+    PRECONDITION_FAILED,
+    CONTENT_TOO_LARGE,
+    URI_TOO_LONG,
+    UNSUPPORTED_MEDIA_TYPE,
+    RANGE_NOT_SATISFIABLE,
+    EXPECTATION_FAILED,
+    IM_A_TEAPOT,
+    MISDIRECTED_REQUEST,
+    UNPROCESSABLE_CONTENT,
+    LOCKED,
+    FAILED_DEPENDENCY,
+    TOO_EARLY,
+    UPGRADE_REQUIRED,
+    PRECONDITION_REQUIRED,
+    TOO_MANY_REQUESTS,
+    REQUEST_HEADER_FIELDS_TOO_LARGE,
+    UNAVAILABLE_FOR_LEGAL_REASONS,
+};
+export const SERVER_ERROR_STATUS_CODES = {
+    INTERNAL_SERVER_ERROR,
+    NOT_IMPLEMENTED,
+    BAD_GATEWAY,
+    SERVICE_UNAVAILABLE,
+    GATEWAY_TIMEOUT,
+    HTTP_VERSION_NOT_SUPPORTED,
+    VARIANT_ALSO_NEGOTIATES,
+    INSUFFICIENT_STORAGE,
+    LOOP_DETECTED,
+    NOT_EXTENDED,
+    NETWORK_AUTHENTICATION_REQUIRED,
+};
+/* -------------------------------------------------------------------------- */
+/* Complete Status Map                                                        */
+/* -------------------------------------------------------------------------- */
+export const STATUS_CODES = {
+    ...INFORMATIONAL_STATUS_CODES,
+    ...SUCCESS_STATUS_CODES,
+    ...REDIRECTION_STATUS_CODES,
+    ...CLIENT_ERROR_STATUS_CODES,
+    ...SERVER_ERROR_STATUS_CODES,
+};
+/* -------------------------------------------------------------------------- */
+/* Lookup Helpers                                                             */
+/* -------------------------------------------------------------------------- */
+export function isKnownStatusCode(status) {
+    return Object.values(STATUS_CODES).includes(status);
+}
+export function isInformationalStatusCode(status) {
+    return status >= 100 && status < 200;
+}
+export function isSuccessStatusCode(status) {
+    return status >= 200 && status < 300;
+}
+export function isRedirectionStatusCode(status) {
+    return status >= 300 && status < 400;
+}
+export function isClientErrorStatusCode(status) {
+    return status >= 400 && status < 500;
+}
+export function isServerErrorStatusCode(status) {
+    return status >= 500 && status < 600;
+}
+/* -------------------------------------------------------------------------- */
+/* Frequently Used Status Sets                                                */
+/* -------------------------------------------------------------------------- */
+export const EMPTY_BODY_STATUS_CODES = [NO_CONTENT, RESET_CONTENT];
+export const REDIRECT_STATUS_CODES = [
+    MOVED_PERMANENTLY,
+    FOUND,
+    SEE_OTHER,
+    TEMPORARY_REDIRECT,
+    PERMANENT_REDIRECT,
+];
+export const RETRYABLE_STATUS_CODES = [
+    REQUEST_TIMEOUT,
+    TOO_EARLY,
+    TOO_MANY_REQUESTS,
+    INTERNAL_SERVER_ERROR,
+    BAD_GATEWAY,
+    SERVICE_UNAVAILABLE,
+    GATEWAY_TIMEOUT,
+];
+/* -------------------------------------------------------------------------- */
+/* Default Status                                                             */
+/* -------------------------------------------------------------------------- */
+export const DEFAULT_SUCCESS_STATUS = OK;
+export const DEFAULT_CLIENT_ERROR_STATUS = BAD_REQUEST;
+export const DEFAULT_SERVER_ERROR_STATUS = INTERNAL_SERVER_ERROR;
+//# sourceMappingURL=httpStatusCodes.constant.js.map

package/dist/httpStream/httpStream.backpressure.d.ts

@@ -2,5 +2,14 @@
  * @zudojs/http/httpStream — Backpressure-aware write and drain helpers.
  */
 export declare function writeToStream(stream: NodeJS.WritableStream, chunk: Buffer | Uint8Array | string): Promise<void>;
+/**
+ * Waits for a backpressured writable to drain.
+ *
+ * Control only reaches here because the write buffer is full — that is,
+ * precisely when the peer is slow or already gone. A destroyed socket emits
+ * `'close'` and never emits `'drain'`, so without the close listener this
+ * promise never settles and the whole pipeline stays pinned holding its
+ * buffers: the failure mode a slowloris-style client produces deliberately.
+ */
 export declare function waitForDrain(stream: NodeJS.WritableStream): Promise<void>;
 //# sourceMappingURL=httpStream.backpressure.d.ts.map

package/dist/httpStream/httpStream.backpressure.js

@@ -16,23 +16,58 @@ export async function writeToStream(stream, chunk) {
     }
     await waitForDrain(writable);
 }
+/**
+ * Waits for a backpressured writable to drain.
+ *
+ * Control only reaches here because the write buffer is full — that is,
+ * precisely when the peer is slow or already gone. A destroyed socket emits
+ * `'close'` and never emits `'drain'`, so without the close listener this
+ * promise never settles and the whole pipeline stays pinned holding its
+ * buffers: the failure mode a slowloris-style client produces deliberately.
+ */
 export async function waitForDrain(stream) {
+    const writable = stream;
+    if (writable.destroyed) {
+        throw new StreamError("Cannot write to a destroyed stream.", {
+            code: "STREAM_DESTROYED",
+        });
+    }
     await new Promise((resolve, reject) => {
-        const writable = stream;
-        const onDrain = () => {
-            cleanup();
-            resolve();
-        };
-        const onError = (error) => {
-            cleanup();
-            reject(normalizeStreamError(error));
-        };
+        let settled = false;
         const cleanup = () => {
             writable.removeListener("drain", onDrain);
             writable.removeListener("error", onError);
+            writable.removeListener("close", onClose);
         };
+        function onDrain() {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            resolve();
+        }
+        function onError(error) {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            reject(normalizeStreamError(error));
+        }
+        function onClose() {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            reject(new StreamError("Stream was destroyed while awaiting drain.", {
+                code: "STREAM_DESTROYED",
+            }));
+        }
         writable.once("drain", onDrain);
         writable.once("error", onError);
+        writable.once("close", onClose);
     });
 }
 //# sourceMappingURL=httpStream.backpressure.js.map

package/dist/httpStream/httpStream.consume.d.ts

@@ -2,5 +2,13 @@
  * @zudojs/http/httpStream — Consume a readable stream via chunk callback.
  */
 import type { HTTPStreamOptions } from "./httpStream.types.js";
+/**
+ * Consumes a readable stream, handing each chunk to a callback.
+ *
+ * The total byte count is capped at `options.maxBytes`
+ * (default `HTTP_DEFAULTS.BODY_LIMIT`). Without a cap any caller reading a
+ * request body through this module rather than `httpBody` could be driven to
+ * OOM by one unauthenticated chunked request.
+ */
 export declare function consumeStream(stream: NodeJS.ReadableStream, onChunk: (chunk: unknown) => void, options?: HTTPStreamOptions): Promise<void>;
 //# sourceMappingURL=httpStream.consume.d.ts.map

package/dist/httpStream/httpStream.consume.js

@@ -2,24 +2,48 @@
  * @zudojs/http/httpStream — Consume a readable stream via chunk callback.
  */
 import { HttpStreamError as StreamError } from "@zudojs/errors";
-import { createAbortError, normalizeStreamError } from "./httpStream.error.js";
+import { createAbortError, createStreamLimitError, normalizeStreamError, } from "./httpStream.error.js";
+import { HTTP_DEFAULTS } from "../httpConstants/http.constants.js";
+import { getChunkSize } from "./httpStream.helper.js";
 import { isReadableEnded } from "./httpStream.state.js";
 import { destroyStream } from "./httpStream.destroy.js";
 import { createSettleGuard, cleanupListeners, wireAbortSignal, } from "./httpStream.eventHelper.js";
+/**
+ * Consumes a readable stream, handing each chunk to a callback.
+ *
+ * The total byte count is capped at `options.maxBytes`
+ * (default `HTTP_DEFAULTS.BODY_LIMIT`). Without a cap any caller reading a
+ * request body through this module rather than `httpBody` could be driven to
+ * OOM by one unauthenticated chunked request.
+ */
 export async function consumeStream(stream, onChunk, options = {}) {
     const signal = options.signal;
     if (signal?.aborted) {
+        destroyStream(stream);
         throw createAbortError();
     }
+    const maxBytes = options.maxBytes ?? HTTP_DEFAULTS.BODY_LIMIT;
+    let total = 0;
     await new Promise((resolve, reject) => {
         const guard = createSettleGuard();
-        let cleanupFn;
+        /*
+         * Declared before any listener is attached: `finish` calls it, and a
+         * stream implementation that emits synchronously during registration
+         * would otherwise hit it in its temporal dead zone.
+         */
+        let cleanupFn = () => { };
         const finish = (error) => {
             if (guard.settled())
                 return;
             guard.mark();
             cleanupFn();
             if (error) {
+                /*
+                 * Removing the `data` listener does not pause a flowing stream, so a
+                 * consumer that rejected — a size limit, a validation failure — would
+                 * otherwise keep receiving the rest of the body into the process.
+                 */
+                destroyStream(stream);
                 reject(normalizeStreamError(error));
             }
             else {
@@ -28,6 +52,11 @@ export async function consumeStream(stream, onChunk, options = {}) {
         };
         const onData = (chunk) => {
             try {
+                total += getChunkSize(chunk);
+                if (total > maxBytes) {
+                    finish(createStreamLimitError(maxBytes, total));
+                    return;
+                }
                 onChunk(chunk);
             }
             catch (error) {
@@ -48,7 +77,6 @@ export async function consumeStream(stream, onChunk, options = {}) {
             }
         };
         const onAbort = () => {
-            destroyStream(stream);
             finish(createAbortError());
         };
         stream.on("data", onData);

package/dist/httpStream/httpStream.error.d.ts

@@ -4,5 +4,16 @@
 import { HttpStreamError as StreamError } from "@zudojs/errors";
 export { StreamError };
 export declare function createAbortError(): StreamError;
+/**
+ * Wraps a non-`Error` rejection value in a typed stream error.
+ *
+ * The original value is kept as `cause` — without it a rejected object
+ * becomes the string `"[object Object]"` with no stack and nothing to debug
+ * from.
+ */
 export declare function normalizeStreamError(error: unknown): Error;
+/**
+ * Error raised when a stream exceeds its configured byte limit.
+ */
+export declare function createStreamLimitError(limit: number, received: number): StreamError;
 //# sourceMappingURL=httpStream.error.d.ts.map

package/dist/httpStream/httpStream.error.js

@@ -8,10 +8,26 @@ export function createAbortError() {
         code: "STREAM_ABORTED",
     });
 }
+/**
+ * Wraps a non-`Error` rejection value in a typed stream error.
+ *
+ * The original value is kept as `cause` — without it a rejected object
+ * becomes the string `"[object Object]"` with no stack and nothing to debug
+ * from.
+ */
 export function normalizeStreamError(error) {
     if (error instanceof Error) {
         return error;
     }
-    return new StreamError(String(error));
+    return new StreamError(String(error), { cause: error });
+}
+/**
+ * Error raised when a stream exceeds its configured byte limit.
+ */
+export function createStreamLimitError(limit, received) {
+    return new StreamError(`Stream exceeded the maximum allowed size of ${limit} bytes.`, {
+        code: "STREAM_LIMIT_EXCEEDED",
+        metadata: { limit, received },
+    });
 }
 //# sourceMappingURL=httpStream.error.js.map

package/dist/httpStream/httpStream.eventHelper.d.ts

@@ -7,7 +7,5 @@ export interface StreamSettleGuard {
 }
 export declare function createSettleGuard(): StreamSettleGuard;
 export declare function cleanupListeners(target: NodeJS.ReadableStream | NodeJS.WritableStream, listeners: ReadonlyArray<readonly [string, (...args: readonly unknown[]) => void]>): void;
-export declare function createFinishHandler(guard: StreamSettleGuard, cleanup: () => void, resolve: (value: void | PromiseLike<void>) => void, reject: (reason: unknown) => void): (error?: unknown) => void;
-export declare function createAbortHandler(guard: StreamSettleGuard, cleanup: () => void, finish: (error?: unknown) => void, streams: ReadonlyArray<NodeJS.ReadableStream | NodeJS.WritableStream>): () => void;
 export declare function wireAbortSignal(signal: AbortSignal | undefined, onAbort: () => void): () => void;
 //# sourceMappingURL=httpStream.eventHelper.d.ts.map

package/dist/httpStream/httpStream.eventHelper.js

@@ -1,8 +1,6 @@
 /**
  * @zudojs/http/httpStream — Shared settle-once guard, cleanup, and abort patterns.
  */
-import { destroyStream } from "./httpStream.destroy.js";
-import { normalizeStreamError } from "./httpStream.error.js";
 export function createSettleGuard() {
     let settled = false;
     return {
@@ -17,28 +15,6 @@ export function cleanupListeners(target, listeners) {
         target.removeListener(event, handler);
     }
 }
-export function createFinishHandler(guard, cleanup, resolve, reject) {
-    return (error) => {
-        if (guard.settled())
-            return;
-        guard.mark();
-        cleanup();
-        if (error) {
-            reject(normalizeStreamError(error));
-        }
-        else {
-            resolve();
-        }
-    };
-}
-export function createAbortHandler(guard, cleanup, finish, streams) {
-    return () => {
-        for (const s of streams) {
-            destroyStream(s);
-        }
-        finish();
-    };
-}
 export function wireAbortSignal(signal, onAbort) {
     if (signal) {
         signal.addEventListener("abort", onAbort, { once: true });

package/dist/httpStream/httpStream.helper.d.ts

@@ -2,7 +2,20 @@
  * @zudojs/http/httpStream — Buffer conversion, chunk size, and readable creation helpers.
  */
 import { Readable } from "node:stream";
+/**
+ * Converts a stream chunk to a Buffer.
+ *
+ * An object-mode chunk is rejected rather than stringified: turning it into
+ * the 15-byte text `"[object Object]"` destroys the data silently and makes
+ * any byte accounting built on it meaningless.
+ */
 export declare function toBuffer(chunk: unknown): Buffer;
+/**
+ * Returns the byte length of a stream chunk.
+ *
+ * Throws for an object-mode chunk: reporting 15 bytes for an arbitrarily
+ * large object would defeat any size limit built on this function.
+ */
 export declare function getChunkSize(chunk: unknown): number;
 export declare function toReadableStream(data: Buffer | Uint8Array | string): Readable;
 //# sourceMappingURL=httpStream.helper.d.ts.map

package/dist/httpStream/httpStream.helper.js

@@ -2,6 +2,13 @@
  * @zudojs/http/httpStream — Buffer conversion, chunk size, and readable creation helpers.
  */
 import { Readable } from "node:stream";
+/**
+ * Converts a stream chunk to a Buffer.
+ *
+ * An object-mode chunk is rejected rather than stringified: turning it into
+ * the 15-byte text `"[object Object]"` destroys the data silently and makes
+ * any byte accounting built on it meaningless.
+ */
 export function toBuffer(chunk) {
     if (Buffer.isBuffer(chunk)) {
         return chunk;
@@ -15,8 +22,14 @@ export function toBuffer(chunk) {
     if (chunk === null || chunk === undefined) {
         return Buffer.alloc(0);
     }
-    return Buffer.from(String(chunk), "utf8");
+    throw new TypeError("Stream chunk must be a Buffer, Uint8Array or string; object-mode streams are not supported.");
 }
+/**
+ * Returns the byte length of a stream chunk.
+ *
+ * Throws for an object-mode chunk: reporting 15 bytes for an arbitrarily
+ * large object would defeat any size limit built on this function.
+ */
 export function getChunkSize(chunk) {
     if (Buffer.isBuffer(chunk)) {
         return chunk.length;
@@ -27,7 +40,10 @@ export function getChunkSize(chunk) {
     if (typeof chunk === "string") {
         return Buffer.byteLength(chunk, "utf8");
     }
-    return Buffer.byteLength(String(chunk), "utf8");
+    if (chunk === null || chunk === undefined) {
+        return 0;
+    }
+    throw new TypeError("Stream chunk must be a Buffer, Uint8Array or string; object-mode streams are not supported.");
 }
 export function toReadableStream(data) {
     return Readable.from([data]);

package/dist/httpStream/httpStream.pipe.js

@@ -2,7 +2,7 @@
  * @zudojs/http/httpStream — Pipe and copy streams between source and destination.
  */
 import { HttpStreamError as StreamError } from "@zudojs/errors";
-import { createAbortError } from "./httpStream.error.js";
+import { createAbortError, createStreamLimitError, normalizeStreamError, } from "./httpStream.error.js";
 import { isReadableEnded, isWritableFinished } from "./httpStream.state.js";
 import { destroyStream } from "./httpStream.destroy.js";
 import { getChunkSize } from "./httpStream.helper.js";
@@ -13,18 +13,20 @@ export async function pipeStream(source, destination, options = {}) {
         destroyStream(source);
         throw createAbortError();
     }
+    const maxBytes = options.maxBytes ?? Number.POSITIVE_INFINITY;
     let bytes = 0;
     let chunks = 0;
     return new Promise((resolve, reject) => {
         const guard = createSettleGuard();
-        let cleanupFn;
+        /* Defined before any listener is attached; see consumeStream. */
+        let cleanupFn = () => { };
         const finish = (error) => {
             if (guard.settled())
                 return;
             guard.mark();
             cleanupFn();
             if (error) {
-                reject(error instanceof Error ? error : new Error(String(error)));
+                reject(normalizeStreamError(error));
             }
             else {
                 resolve({ bytes });
@@ -33,7 +35,16 @@ export async function pipeStream(source, destination, options = {}) {
         const onData = (chunk) => {
             chunks += 1;
             bytes += getChunkSize(chunk);
+            if (bytes > maxBytes) {
+                destroyStream(source);
+                destroyStream(destination);
+                finish(createStreamLimitError(maxBytes, bytes));
+            }
         };
+        /*
+         * `end` is driven from here alone — the pipe below is created with
+         * `{ end: false }` — so the destination is never ended twice.
+         */
         const onEnd = () => {
             if (options.end === false) {
                 finish();
@@ -94,7 +105,7 @@ export async function pipeStream(source, destination, options = {}) {
             removeAbort();
         };
         try {
-            source.pipe(destination, { end: options.end !== false });
+            source.pipe(destination, { end: false });
         }
         catch (error) {
             finish(error);