@duplojs/http 0.9.5 → 0.11.0

package/dist/core/serverSentEvents.mjs

@@ -1,94 +1,42 @@
 import { stringToMillisecond } from '@duplojs/utils';
+import { Stream } from './stream.mjs';
 
 /* eslint-disable @typescript-eslint/prefer-for-of */
 var ServerSentEvents;
 (function (ServerSentEvents) {
     const regexServerSentEventSplitStringData = /\r\n|\r|\n/;
     const nullIdRegexp = /\0|\n|\r/;
-    function init(response, initParams) {
-        const abortSubscribers = [];
-        let isAbort = false;
-        const handler = {
-            async start(send, close) {
-                if (isAbort) {
-                    return;
+    function init(startSendingEvents, initParams) {
+        return Stream.init((streamParams) => startSendingEvents({
+            ...streamParams,
+            lastId: initParams.lastId,
+            send: (event, data, params) => {
+                if (streamParams.isClose()) {
+                    return Promise.resolve();
                 }
-                let isClose = false;
-                const closeSubscribers = [];
-                const errorSubscribers = [];
-                const params = {
-                    send: (event, data, params) => {
-                        if (isClose) {
-                            return Promise.resolve();
-                        }
-                        else if (isAbort) {
-                            return Promise.resolve();
-                        }
-                        let content = `event: ${event || "message"}\n`;
-                        if (typeof data === "string") {
-                            const splitData = data.split(regexServerSentEventSplitStringData);
-                            for (let index = 0; index < splitData.length; index++) {
-                                content += `data: ${splitData[index]}\n`;
-                            }
-                        }
-                        else if (data !== undefined) {
-                            content += `content-type: application/json\ndata: ${JSON.stringify(data)}\n`;
-                        }
-                        if (typeof params?.id === "string" && !nullIdRegexp.test(params.id)) {
-                            content += `id: ${params.id}\n`;
-                        }
-                        if (params?.retry !== undefined) {
-                            content += `retry: ${stringToMillisecond(params.retry)}\n`;
-                        }
-                        content += "\n";
-                        return send(content);
-                    },
-                    abort: handler.abort,
-                    isAbort: () => isAbort,
-                    onAbort: (theFunction) => void abortSubscribers.push(theFunction),
-                    close: () => {
-                        if (isClose === true) {
-                            return;
-                        }
-                        isClose = true;
-                        close();
-                        for (let index = 0; index < closeSubscribers.length; index++) {
-                            closeSubscribers[index]();
-                        }
-                    },
-                    isClose: () => isClose,
-                    onClose: (theFunction) => void closeSubscribers.push(theFunction),
-                    error: (error) => {
-                        for (let index = 0; index < errorSubscribers.length; index++) {
-                            errorSubscribers[index](error);
-                        }
-                    },
-                    onError: (theFunction) => void errorSubscribers.push(theFunction),
-                    lastId: initParams.lastId && !nullIdRegexp.test(initParams.lastId)
-                        ? initParams.lastId
-                        : null,
-                };
-                try {
-                    await response.startSendingEvents(params);
+                else if (streamParams.isAbort()) {
+                    return Promise.resolve();
                 }
-                catch (error) {
-                    params.error(error);
+                let content = `event: ${event || "message"}\n`;
+                if (typeof data === "string") {
+                    const splitData = data.split(regexServerSentEventSplitStringData);
+                    for (let index = 0; index < splitData.length; index++) {
+                        content += `data: ${splitData[index]}\n`;
+                    }
                 }
-                finally {
-                    params.close();
+                else if (data !== undefined) {
+                    content += `content-type: application/json\ndata: ${JSON.stringify(data)}\n`;
                 }
-            },
-            abort() {
-                if (isAbort === true) {
-                    return;
+                if (typeof params?.id === "string" && !nullIdRegexp.test(params.id)) {
+                    content += `id: ${params.id}\n`;
                 }
-                isAbort = true;
-                for (let index = 0; index < abortSubscribers.length; index++) {
-                    abortSubscribers[index]();
+                if (params?.retry !== undefined) {
+                    content += `retry: ${stringToMillisecond(params.retry)}\n`;
                 }
+                content += "\n";
+                return streamParams.send(content);
             },
-        };
-        return handler;
+        }));
     }
     ServerSentEvents.init = init;
 })(ServerSentEvents || (ServerSentEvents = {}));

package/dist/core/steps/handler.d.ts

@@ -1,19 +1,29 @@
 import { type MaybePromise, type Kind, type MaybeArray } from "@duplojs/utils";
 import { type StepKind } from "./kind";
 import { type Floor } from "../floor";
-import { type ServerSentEventsPredictedResponse, type PredictedResponse, type ResponseContract } from "../response";
+import { type ServerSentEventsPredictedResponse, type PredictedResponse, type ResponseContract, type PredictedResponses, type StreamPredictedResponse, type StreamTextPredictedResponse } from "../response";
 import { type StepFunctionParams } from "./types";
 import { type Metadata } from "../metadata";
-interface HandlerStepFunctionParamsServerSentEventsResponse<GenericResponse extends ServerSentEventsPredictedResponse> {
+export interface HandlerStepFunctionParamsServerSentEventsResponse<GenericResponse extends ServerSentEventsPredictedResponse> {
     serverSentEventsResponse<GenericInformation extends GenericResponse["information"], GenericFilteredResponse extends Extract<GenericResponse, {
         information: GenericInformation;
     }>>(information: GenericInformation, startSendingEvents: GenericFilteredResponse["startSendingEvents"]): GenericFilteredResponse;
 }
-export interface HandlerStepFunctionParams<GenericResponse extends PredictedResponse | ServerSentEventsPredictedResponse = PredictedResponse | ServerSentEventsPredictedResponse> extends StepFunctionParams<Extract<GenericResponse, PredictedResponse>>, HandlerStepFunctionParamsServerSentEventsResponse<Extract<GenericResponse, ServerSentEventsPredictedResponse>> {
+interface HandlerStepFunctionParamsStreamResponse<GenericResponse extends StreamPredictedResponse> {
+    streamResponse<GenericInformation extends GenericResponse["information"], GenericFilteredResponse extends Extract<GenericResponse, {
+        information: GenericInformation;
+    }>>(information: GenericInformation, startStream: GenericFilteredResponse["startStream"]): GenericFilteredResponse;
+}
+interface HandlerStepFunctionParamsStreamTextResponse<GenericResponse extends StreamTextPredictedResponse> {
+    streamTextResponse<GenericInformation extends GenericResponse["information"], GenericFilteredResponse extends Extract<GenericResponse, {
+        information: GenericInformation;
+    }>>(information: GenericInformation, startStream: GenericFilteredResponse["startStream"]): GenericFilteredResponse;
+}
+export interface HandlerStepFunctionParams<GenericResponse extends PredictedResponses = PredictedResponses> extends StepFunctionParams<Extract<GenericResponse, PredictedResponse>>, HandlerStepFunctionParamsServerSentEventsResponse<Extract<GenericResponse, ServerSentEventsPredictedResponse>>, HandlerStepFunctionParamsStreamResponse<Extract<GenericResponse, StreamPredictedResponse>>, HandlerStepFunctionParamsStreamTextResponse<Extract<GenericResponse, StreamTextPredictedResponse>> {
 }
 export interface HandlerStepDefinition {
-    theFunction(floor: Floor, params: HandlerStepFunctionParams): MaybePromise<PredictedResponse | ServerSentEventsPredictedResponse>;
-    readonly responseContract: MaybeArray<ResponseContract.Contract | ResponseContract.ServerSentEventsContract>;
+    theFunction(floor: Floor, params: HandlerStepFunctionParams): MaybePromise<PredictedResponses>;
+    readonly responseContract: MaybeArray<ResponseContract.Contracts>;
     readonly metadata: readonly Metadata[];
 }
 export declare const handlerStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/handler-step", unknown>>;

package/dist/core/stream.cjs

@@ -0,0 +1,73 @@
+'use strict';
+
+exports.Stream = void 0;
+(function (Stream) {
+    function init(startStream) {
+        const abortSubscribers = [];
+        let isAbort = false;
+        const handler = {
+            async start(send, close) {
+                if (isAbort) {
+                    return;
+                }
+                let isClose = false;
+                const closeSubscribers = [];
+                const errorSubscribers = [];
+                const params = {
+                    send: async (...args) => {
+                        if (isClose) {
+                            return Promise.resolve();
+                        }
+                        else if (isAbort) {
+                            return Promise.resolve();
+                        }
+                        for (let index = 0; index < args.length; index++) {
+                            await send(args[index]);
+                        }
+                    },
+                    abort: handler.abort,
+                    isAbort: () => isAbort,
+                    onAbort: (theFunction) => void abortSubscribers.push(theFunction),
+                    close: () => {
+                        if (isClose === true) {
+                            return;
+                        }
+                        isClose = true;
+                        close();
+                        for (let index = 0; index < closeSubscribers.length; index++) {
+                            closeSubscribers[index]();
+                        }
+                    },
+                    isClose: () => isClose,
+                    onClose: (theFunction) => void closeSubscribers.push(theFunction),
+                    error: (error) => {
+                        for (let index = 0; index < errorSubscribers.length; index++) {
+                            errorSubscribers[index](error);
+                        }
+                    },
+                    onError: (theFunction) => void errorSubscribers.push(theFunction),
+                };
+                try {
+                    await startStream(params);
+                }
+                catch (error) {
+                    params.error(error);
+                }
+                finally {
+                    params.close();
+                }
+            },
+            abort() {
+                if (isAbort === true) {
+                    return;
+                }
+                isAbort = true;
+                for (let index = 0; index < abortSubscribers.length; index++) {
+                    abortSubscribers[index]();
+                }
+            },
+        };
+        return handler;
+    }
+    Stream.init = init;
+})(exports.Stream || (exports.Stream = {}));

package/dist/core/stream.d.ts

@@ -0,0 +1,19 @@
+import { type MaybePromise, type AnyTuple } from "@duplojs/utils";
+export declare namespace Stream {
+    interface StartSendingParams<GenericFlux extends unknown = unknown> {
+        send(...args: AnyTuple<GenericFlux>): Promise<void>;
+        abort(): void;
+        onAbort(theFunction: () => void): void;
+        isAbort(): boolean;
+        close(): void;
+        onClose(theFunction: () => void): void;
+        isClose(): boolean;
+        error(error: unknown): void;
+        onError(theFunction: (error: unknown) => void): void;
+    }
+    interface Handler {
+        start(send: (value: unknown) => Promise<void>, close: () => void): Promise<void>;
+        abort(): void;
+    }
+    function init(startStream: (params: StartSendingParams) => MaybePromise<void>): Handler;
+}

package/dist/core/stream.mjs

@@ -0,0 +1,73 @@
+var Stream;
+(function (Stream) {
+    function init(startStream) {
+        const abortSubscribers = [];
+        let isAbort = false;
+        const handler = {
+            async start(send, close) {
+                if (isAbort) {
+                    return;
+                }
+                let isClose = false;
+                const closeSubscribers = [];
+                const errorSubscribers = [];
+                const params = {
+                    send: async (...args) => {
+                        if (isClose) {
+                            return Promise.resolve();
+                        }
+                        else if (isAbort) {
+                            return Promise.resolve();
+                        }
+                        for (let index = 0; index < args.length; index++) {
+                            await send(args[index]);
+                        }
+                    },
+                    abort: handler.abort,
+                    isAbort: () => isAbort,
+                    onAbort: (theFunction) => void abortSubscribers.push(theFunction),
+                    close: () => {
+                        if (isClose === true) {
+                            return;
+                        }
+                        isClose = true;
+                        close();
+                        for (let index = 0; index < closeSubscribers.length; index++) {
+                            closeSubscribers[index]();
+                        }
+                    },
+                    isClose: () => isClose,
+                    onClose: (theFunction) => void closeSubscribers.push(theFunction),
+                    error: (error) => {
+                        for (let index = 0; index < errorSubscribers.length; index++) {
+                            errorSubscribers[index](error);
+                        }
+                    },
+                    onError: (theFunction) => void errorSubscribers.push(theFunction),
+                };
+                try {
+                    await startStream(params);
+                }
+                catch (error) {
+                    params.error(error);
+                }
+                finally {
+                    params.close();
+                }
+            },
+            abort() {
+                if (isAbort === true) {
+                    return;
+                }
+                isAbort = true;
+                for (let index = 0; index < abortSubscribers.length; index++) {
+                    abortSubscribers[index]();
+                }
+            },
+        };
+        return handler;
+    }
+    Stream.init = init;
+})(Stream || (Stream = {}));
+
+export { Stream };

package/dist/interfaces/node/bodyReaders/formData/index.cjs

@@ -102,7 +102,7 @@ function createFormDataBodyReaderImplementation(serverParams) {
             }
             return result;
         }
-        if (request.headers["content-type-options"]?.includes("advanced")) {
+        if (request.headers["x-duplojs-body-options"]?.includes("advanced")) {
             return utils.E.success(utils.TheFormData.fromEntries(result.entries(), params.maxIndexArray));
         }
         return utils.E.success(utils.O.fromEntries(result.entries()));

package/dist/interfaces/node/bodyReaders/formData/index.mjs

@@ -100,7 +100,7 @@ function createFormDataBodyReaderImplementation(serverParams) {
             }
             return result;
         }
-        if (request.headers["content-type-options"]?.includes("advanced")) {
+        if (request.headers["x-duplojs-body-options"]?.includes("advanced")) {
             return E.success(TheFormData.fromEntries(result.entries(), params.maxIndexArray));
         }
         return E.success(O.fromEntries(result.entries()));

package/dist/interfaces/node/hooks/index.cjs

@@ -3,11 +3,14 @@
 require('../../../core/response/index.cjs');
 require('../../../core/route/index.cjs');
 var serverSentEvents = require('../../../core/serverSentEvents.cjs');
+var stream = require('../../../core/stream.cjs');
 var serverUtils = require('@duplojs/server-utils');
 var utils = require('@duplojs/utils');
 var node_fs = require('node:fs');
 var hooks = require('../../../core/route/hooks.cjs');
 var serverSentEventsPredicted = require('../../../core/response/serverSentEventsPredicted.cjs');
+var streamPredicted = require('../../../core/response/streamPredicted.cjs');
+var streamTextPredicted = require('../../../core/response/streamTextPredicted.cjs');
 
 function initNodeHook(hub, serverParams) {
     const isDev = hub.config.environment === "DEV";
@@ -19,7 +22,7 @@ function initNodeHook(hub, serverParams) {
         async sendResponse({ request, currentResponse, exit }) {
             const { response: rawResponse, request: rawRequest } = request.raw;
             if (currentResponse instanceof serverSentEventsPredicted.ServerSentEventsPredictedResponse) {
-                const handler = serverSentEvents.ServerSentEvents.init(currentResponse, {
+                const handler = serverSentEvents.ServerSentEvents.init(currentResponse.startSendingEvents, {
                     lastId: typeof request.headers["last-event-id"] === "string"
                         ? request.headers["last-event-id"]
                         : null,
@@ -35,6 +38,23 @@ function initNodeHook(hub, serverParams) {
                 }), () => void rawResponse.end());
                 return exit();
             }
+            else if (currentResponse instanceof streamPredicted.StreamPredictedResponse
+                || currentResponse instanceof streamTextPredicted.StreamTextPredictedResponse) {
+                const handler = stream.Stream.init(currentResponse.startStream);
+                rawRequest.on("close", handler.abort);
+                void handler.start((value) => new Promise((resolve) => {
+                    if (!rawResponse.write((value instanceof Buffer
+                        || value instanceof Uint8Array)
+                        ? value
+                        : String(value))) {
+                        rawResponse.once("drain", resolve);
+                    }
+                    else {
+                        resolve();
+                    }
+                }), () => void rawResponse.end());
+                return exit();
+            }
             const body = currentResponse.body;
             if (body instanceof Error) {
                 rawResponse.write(body.toString());

package/dist/interfaces/node/hooks/index.mjs

@@ -1,11 +1,14 @@
 import '../../../core/response/index.mjs';
 import '../../../core/route/index.mjs';
 import { ServerSentEvents } from '../../../core/serverSentEvents.mjs';
+import { Stream } from '../../../core/stream.mjs';
 import { SF } from '@duplojs/server-utils';
 import { A } from '@duplojs/utils';
 import { createReadStream } from 'node:fs';
 import { createHookRouteLifeCycle } from '../../../core/route/hooks.mjs';
 import { ServerSentEventsPredictedResponse } from '../../../core/response/serverSentEventsPredicted.mjs';
+import { StreamPredictedResponse } from '../../../core/response/streamPredicted.mjs';
+import { StreamTextPredictedResponse } from '../../../core/response/streamTextPredicted.mjs';
 
 function initNodeHook(hub, serverParams) {
     const isDev = hub.config.environment === "DEV";
@@ -17,7 +20,7 @@ function initNodeHook(hub, serverParams) {
         async sendResponse({ request, currentResponse, exit }) {
             const { response: rawResponse, request: rawRequest } = request.raw;
             if (currentResponse instanceof ServerSentEventsPredictedResponse) {
-                const handler = ServerSentEvents.init(currentResponse, {
+                const handler = ServerSentEvents.init(currentResponse.startSendingEvents, {
                     lastId: typeof request.headers["last-event-id"] === "string"
                         ? request.headers["last-event-id"]
                         : null,
@@ -33,6 +36,23 @@ function initNodeHook(hub, serverParams) {
                 }), () => void rawResponse.end());
                 return exit();
             }
+            else if (currentResponse instanceof StreamPredictedResponse
+                || currentResponse instanceof StreamTextPredictedResponse) {
+                const handler = Stream.init(currentResponse.startStream);
+                rawRequest.on("close", handler.abort);
+                void handler.start((value) => new Promise((resolve) => {
+                    if (!rawResponse.write((value instanceof Buffer
+                        || value instanceof Uint8Array)
+                        ? value
+                        : String(value))) {
+                        rawResponse.once("drain", resolve);
+                    }
+                    else {
+                        resolve();
+                    }
+                }), () => void rawResponse.end());
+                return exit();
+            }
             const body = currentResponse.body;
             if (body instanceof Error) {
                 rawResponse.write(body.toString());

package/dist/interfaces/node/index.cjs

@@ -3,21 +3,21 @@
 require('./types/index.cjs');
 var kind = require('./kind.cjs');
 var createHttpServer = require('./createHttpServer.cjs');
-var index = require('./hooks/index.cjs');
+var index$2 = require('./hooks/index.cjs');
 require('./bodyReaders/index.cjs');
 var error = require('./bodyReaders/formData/error.cjs');
+var index = require('./bodyReaders/formData/index.cjs');
+var index$1 = require('./bodyReaders/text/index.cjs');
 var readRequestFormData = require('./bodyReaders/formData/readRequestFormData.cjs');
-var index$1 = require('./bodyReaders/formData/index.cjs');
 var readRequestText = require('./bodyReaders/text/readRequestText.cjs');
-var index$2 = require('./bodyReaders/text/index.cjs');
 
 
 
 exports.createInterfacesNodeLibKind = kind.createInterfacesNodeLibKind;
 exports.createHttpServer = createHttpServer.createHttpServer;
-exports.initNodeHook = index.initNodeHook;
+exports.initNodeHook = index$2.initNodeHook;
 exports.BodyParseFormDataError = error.BodyParseFormDataError;
+exports.createFormDataBodyReaderImplementation = index.createFormDataBodyReaderImplementation;
+exports.createTextBodyReaderImplementation = index$1.createTextBodyReaderImplementation;
 exports.readRequestFormData = readRequestFormData.readRequestFormData;
-exports.createFormDataBodyReaderImplementation = index$1.createFormDataBodyReaderImplementation;
 exports.readRequestText = readRequestText.readRequestText;
-exports.createTextBodyReaderImplementation = index$2.createTextBodyReaderImplementation;

package/dist/interfaces/node/index.mjs

@@ -4,7 +4,7 @@ export { createHttpServer } from './createHttpServer.mjs';
 export { initNodeHook } from './hooks/index.mjs';
 import './bodyReaders/index.mjs';
 export { BodyParseFormDataError } from './bodyReaders/formData/error.mjs';
-export { readRequestFormData } from './bodyReaders/formData/readRequestFormData.mjs';
 export { createFormDataBodyReaderImplementation } from './bodyReaders/formData/index.mjs';
-export { readRequestText } from './bodyReaders/text/readRequestText.mjs';
 export { createTextBodyReaderImplementation } from './bodyReaders/text/index.mjs';
+export { readRequestFormData } from './bodyReaders/formData/readRequestFormData.mjs';
+export { readRequestText } from './bodyReaders/text/readRequestText.mjs';

package/dist/plugins/codeGenerator/aggregateStepContract.cjs

@@ -4,6 +4,7 @@ require('../../core/steps/index.cjs');
 var utils = require('@duplojs/utils');
 require('../../core/response/index.cjs');
 var metadata = require('./metadata.cjs');
+var typescript = require('typescript');
 var identifier = require('../../core/steps/identifier.cjs');
 var process = require('../../core/steps/process.cjs');
 var extract = require('../../core/steps/extract.cjs');
@@ -13,6 +14,7 @@ var cut = require('../../core/steps/cut.cjs');
 var handler = require('../../core/steps/handler.cjs');
 var contract = require('../../core/response/contract.cjs');
 
+const defaultFluxStreamSchema = utils.DP.unknown().setOverrideTypescriptTransformer(typescript.factory.createTypeReferenceNode("Uint8Array", [typescript.factory.createTypeReferenceNode("ArrayBuffer")]));
 function aggregateStepContract(steps, params) {
     const filteredStep = utils.A.filter(steps, (step) => utils.A.find(step.definition.metadata, metadata.IgnoreByCodeGeneratorMetadata.is) === undefined);
     const processContracts = utils.pipe(filteredStep, utils.A.filter(identifier.stepIdentifier(process.processStepKind)), utils.A.filter((step) => utils.A.find(step.definition.process.definition.metadata, metadata.IgnoreByCodeGeneratorMetadata.is) === undefined), utils.A.map((element) => aggregateStepContract(element.definition.process.definition.steps, params)), utils.O.to({
@@ -66,6 +68,16 @@ function aggregateStepContract(steps, params) {
         information: utils.DP.literal(information),
         body,
         events: utils.DP.object(events),
+    })), utils.P.when(contract.ResponseContract.streamContractKind.has, ({ code, information, body }) => utils.DP.object({
+        code: utils.DP.literal(code),
+        information: utils.DP.literal(information),
+        body,
+        flux: defaultFluxStreamSchema,
+    })), utils.P.when(contract.ResponseContract.streamTextContractKind.has, ({ code, information, body, flux }) => utils.DP.object({
+        code: utils.DP.literal(code),
+        information: utils.DP.literal(information),
+        body,
+        flux,
     })), utils.P.exhaustive)), utils.A.concat(processContracts.endpointContract));
     return {
         entrypointContract,

package/dist/plugins/codeGenerator/aggregateStepContract.mjs

@@ -1,7 +1,8 @@
 import '../../core/steps/index.mjs';
-import { A, pipe, O, DP, P, hasSomeKinds, innerPipe } from '@duplojs/utils';
+import { DP, A, pipe, O, P, hasSomeKinds, innerPipe } from '@duplojs/utils';
 import '../../core/response/index.mjs';
 import { IgnoreByCodeGeneratorMetadata } from './metadata.mjs';
+import { factory } from 'typescript';
 import { stepIdentifier } from '../../core/steps/identifier.mjs';
 import { processStepKind } from '../../core/steps/process.mjs';
 import { extractStepKind } from '../../core/steps/extract.mjs';
@@ -11,6 +12,7 @@ import { cutStepKind } from '../../core/steps/cut.mjs';
 import { handlerStepKind } from '../../core/steps/handler.mjs';
 import { ResponseContract } from '../../core/response/contract.mjs';
 
+const defaultFluxStreamSchema = DP.unknown().setOverrideTypescriptTransformer(factory.createTypeReferenceNode("Uint8Array", [factory.createTypeReferenceNode("ArrayBuffer")]));
 function aggregateStepContract(steps, params) {
     const filteredStep = A.filter(steps, (step) => A.find(step.definition.metadata, IgnoreByCodeGeneratorMetadata.is) === undefined);
     const processContracts = pipe(filteredStep, A.filter(stepIdentifier(processStepKind)), A.filter((step) => A.find(step.definition.process.definition.metadata, IgnoreByCodeGeneratorMetadata.is) === undefined), A.map((element) => aggregateStepContract(element.definition.process.definition.steps, params)), O.to({
@@ -64,6 +66,16 @@ function aggregateStepContract(steps, params) {
         information: DP.literal(information),
         body,
         events: DP.object(events),
+    })), P.when(ResponseContract.streamContractKind.has, ({ code, information, body }) => DP.object({
+        code: DP.literal(code),
+        information: DP.literal(information),
+        body,
+        flux: defaultFluxStreamSchema,
+    })), P.when(ResponseContract.streamTextContractKind.has, ({ code, information, body, flux }) => DP.object({
+        code: DP.literal(code),
+        information: DP.literal(information),
+        body,
+        flux,
     })), P.exhaustive)), A.concat(processContracts.endpointContract));
     return {
         entrypointContract,

package/dist/plugins/cookie/hooks/cookieHooks.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var parser = require('../parser.cjs');
+var serialize = require('../serialize.cjs');
+var parseRequestCookie = require('./parseRequestCookie.cjs');
+var serializeResponseCookie = require('./serializeResponseCookie.cjs');
+
+function cookieHooks({ parser: parser$1 = parser.defaultParser, serializer = serialize.defaultSerializer, } = {}) {
+    return {
+        ...parseRequestCookie.parseRequestCookieHook({ parser: parser$1 }),
+        ...serializeResponseCookie.serializeResponseCookieHook({ serializer }),
+    };
+}
+
+exports.cookieHooks = cookieHooks;

package/dist/plugins/cookie/hooks/cookieHooks.d.ts

@@ -0,0 +1,11 @@
+import { type Parser } from "../parser";
+import { type Serializer } from "../serialize";
+interface CookieHooksParams {
+    parser?: Parser;
+    serializer?: Serializer;
+}
+export declare function cookieHooks({ parser, serializer, }?: CookieHooksParams): {
+    beforeSendResponse: ({ currentResponse, next }: import("../../../core/route").RouteHookParamsAfter) => import("../../../core/route").RouteHookNext;
+    beforeRouteExecution: ({ request, next }: import("../../../core/route").RouteHookParams) => import("../../../core/route").RouteHookNext;
+};
+export {};

package/dist/plugins/cookie/hooks/cookieHooks.mjs

@@ -0,0 +1,13 @@
+import { defaultParser } from '../parser.mjs';
+import { defaultSerializer } from '../serialize.mjs';
+import { parseRequestCookieHook } from './parseRequestCookie.mjs';
+import { serializeResponseCookieHook } from './serializeResponseCookie.mjs';
+
+function cookieHooks({ parser = defaultParser, serializer = defaultSerializer, } = {}) {
+    return {
+        ...parseRequestCookieHook({ parser }),
+        ...serializeResponseCookieHook({ serializer }),
+    };
+}
+
+export { cookieHooks };

package/dist/plugins/cookie/hooks/index.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var parseRequestCookie = require('./parseRequestCookie.cjs');
+var serializeResponseCookie = require('./serializeResponseCookie.cjs');
+var cookieHooks = require('./cookieHooks.cjs');
+
+
+
+exports.parseRequestCookieHook = parseRequestCookie.parseRequestCookieHook;
+exports.serializeResponseCookieHook = serializeResponseCookie.serializeResponseCookieHook;
+exports.cookieHooks = cookieHooks.cookieHooks;

package/dist/plugins/cookie/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./parseRequestCookie";
+export * from "./serializeResponseCookie";
+export * from "./cookieHooks";

package/dist/plugins/cookie/hooks/index.mjs

@@ -0,0 +1,3 @@
+export { parseRequestCookieHook } from './parseRequestCookie.mjs';
+export { serializeResponseCookieHook } from './serializeResponseCookie.mjs';
+export { cookieHooks } from './cookieHooks.mjs';

package/dist/plugins/cookie/hooks/parseRequestCookie.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+require('../../../core/route/index.cjs');
+var hooks = require('../../../core/route/hooks.cjs');
+
+function parseRequestCookieHook(params) {
+    return hooks.createHookRouteLifeCycle({
+        beforeRouteExecution: ({ request, next }) => {
+            if (request.headers.cookie) {
+                const cookieValue = Array.isArray(request.headers.cookie)
+                    ? request.headers.cookie.join("; ")
+                    : request.headers.cookie;
+                request.cookies = params.parser(cookieValue);
+            }
+            return next();
+        },
+    });
+}
+
+exports.parseRequestCookieHook = parseRequestCookieHook;

package/dist/plugins/cookie/hooks/parseRequestCookie.d.ts

@@ -0,0 +1,8 @@
+import { type Parser } from "../parser";
+interface ParseRequestCookieHookParams {
+    parser: Parser;
+}
+export declare function parseRequestCookieHook(params: ParseRequestCookieHookParams): {
+    readonly beforeRouteExecution: ({ request, next }: import("../../../core/route").RouteHookParams) => import("../../../core/route").RouteHookNext;
+};
+export {};