@vyriy/handler 0.3.0 → 0.3.4

package/AGENTS.md

@@ -1,41 +1,62 @@
-# Vyriy Package Agent Guide
+# Project Agent Guide
 
-This package belongs to the Vyriy toolkit. Keep changes calm, explicit, reusable, and easy to reason about.
+This repository follows a calm engineering style: changes should be explicit, reusable, typed, documented, tested, and easy to reason about.
 
-## Architecture
+Use this guide as the default behavior for AI agents and contributors working in this repository. Prefer local package conventions when they are more specific than this document.
+
+## Core Principles
 
 - Prefer simple modules over clever frameworks or hidden conventions.
-- Keep package boundaries explicit and avoid project-specific coupling.
+- Keep package and project boundaries explicit.
+- Avoid project-specific coupling in reusable code.
 - Extract only proven reusable behavior.
 - Keep public APIs small, typed, documented, and stable.
-- Prefer SSR-friendly and SSG-friendly code paths.
-- Keep integrations replaceable and avoid hard coupling to a CMS or runtime host.
-- Prefer AWS serverless-compatible assumptions when infrastructure concerns appear.
+- Prefer SSR-friendly and SSG-friendly code paths when working with frontend or shared code.
+- Keep integrations replaceable and avoid hard coupling to a CMS, framework, vendor, or runtime host.
+- Prefer infrastructure assumptions that are easy to deploy, observe, and replace.
+- Prefer the option that is simpler to explain, easier to evolve, and calmer to maintain.
 
 ## File Shape
 
-- Prefer one exported runtime method, component, or helper per production file when it stays readable.
+- Prefer one exported runtime method, component, helper, or class per production file when it stays readable.
 - Prefer one matching test file per production file, for example `feature.ts` and `feature.test.ts`.
 - Use focused folders when behavior naturally splits into several related files.
 - Keep `index.ts` as a public re-export surface only. Do not place implementation logic in it.
-- Use `.js` relative import and export specifiers in TypeScript source where package style requires it.
+- Use relative import and export specifiers that match the package module style.
+- Use `.js` relative specifiers in TypeScript source for ESM/NodeNext packages.
 - Add `types.ts` when public shared types are part of the package contract.
 - Keep constants near the code that owns them unless they are shared or clarify repeated behavior.
 
 ## Public Surface
 
-- Every new public export should be re-exported from `index.ts`.
-- Add or update `index.test.ts` when the public export surface changes.
+- Every new public export must be re-exported from the package or module public entry point.
+- Add or update public-surface tests when exports change.
 - Add JSDoc for public exports when behavior, parameters, return values, or usage expectations need explanation.
-- Do not hand-maintain source package `exports` maps unless the package has a real custom publishing need.
+- Avoid exporting internal helpers only to make tests easier.
+- Do not hand-maintain package `exports` maps unless the project has a real custom publishing need.
 
 ## Tests
 
-- Tests use Jest and `@jest/globals`.
 - Cover public behavior and meaningful edge cases.
 - Prefer behavior-focused tests over private implementation lock-in.
+- Keep tests deterministic.
+- Avoid real network, filesystem, timers, browser, or cloud dependencies unless the behavior specifically requires them.
 - When mocking modules, install mocks before loading the module under test.
-- Use focused validation when changing package behavior:
+- Use focused validation when changing behavior.
+
+Example validation commands:
+
+```bash
+yarn test
+```
+
+For workspaces, prefer the project convention, for example:
+
+```bash
+yarn workspace <package-name> test
+```
+
+For Jest-based packages, focused validation may look like:
 
 ```bash
 yarn jest packages/<package> --runInBand --coverage=false
@@ -44,22 +65,38 @@ yarn jest packages/<package> --runInBand --coverage=false
 ## Documentation
 
 - Keep `README.md` concise and usage-oriented.
-- Start package READMEs with `# @vyriy/<package>`.
+- Start package READMEs with `# <package>`.
 - Document real public exports, supported options, and examples that actually work.
-- Keep `doc.mdx` as the Storybook/docs wrapper for the README when the package participates in docs.
-- For component packages, include Storybook coverage for supported states and common usage.
+- Update docs when public behavior changes.
+- Keep generated docs wrappers, such as `doc.mdx`, aligned with the README when the project uses them.
+- For component packages, include visual documentation or stories for supported states and common usage.
 
 ## Components
 
-- Prefer lightweight React 19+ components with TypeScript.
+- Prefer lightweight React components with TypeScript when working in React packages.
 - Keep components SSR-friendly and avoid browser globals during render.
-- Prefer composable props and Bootstrap-compatible ergonomics where practical.
+- Prefer composable props and predictable ergonomics.
 - Put each public component in its own file with a matching test.
-- Add Storybook stories when a component has visual states, variants, or interaction states.
+- Add stories or examples when a component has visual states, variants, or interaction states.
+- Keep styling explicit and reusable. Avoid hidden theme assumptions unless they are part of the package contract.
 
 ## Change Discipline
 
 - Keep changes scoped to the requested behavior.
 - Avoid unrelated refactors and metadata churn.
-- Sync implementation, tests, README, `doc.mdx`, and public re-exports together.
-- Prefer the option that is simpler to explain, easier to evolve, and calmer to maintain.
+- Sync implementation, tests, docs, examples, and public re-exports together.
+- Do not introduce new dependencies unless they clearly reduce complexity or are already part of the project direction.
+- Prefer small, reviewable changes over broad rewrites.
+- Preserve existing conventions unless there is a clear reason to change them.
+
+## Before Finishing
+
+Check that the change is complete:
+
+- Public exports are updated.
+- Public-surface tests are updated when exports change.
+- Matching unit tests exist for new behavior.
+- README examples still match the real API.
+- Visual docs, stories, or examples are updated for visible component behavior.
+- TypeScript imports follow the package module style.
+- No unrelated files, formatting churn, or generated artifacts were changed.

package/README.md

@@ -45,33 +45,31 @@ export const handler = api(async (event) => ({
 }));
 ```
 
-For Lambda response streaming, keep the reusable handler separate from the runtime entrypoints:
+For Lambda response streaming, use the separate stream chain:
 
 ```ts
 // handler.ts
-import { api, streamify } from '@vyriy/handler';
+import { streamApi } from '@vyriy/handler';
 
-export const handler = streamify(
-  api(async (event, responseStream, context) => {
-    responseStream.setContentType?.('text/plain');
-    responseStream.write(`Request path: ${event.path}\n`);
-    responseStream.write(`Request id: ${context.awsRequestId}\n`);
-    responseStream.write('Part 1 of the response...');
-    responseStream.write('Part 2 of the response...');
-    responseStream.end();
-  }),
-);
+export const handler = streamApi(async (event, responseStream) => {
+  responseStream.setContentType?.('text/plain');
+  responseStream.write(`Request path: ${event.path}\n`);
+  responseStream.write('Part 1 of the response...');
+  responseStream.end('Part 2 of the response...');
+});
 ```
 
+`streamApi(...)` handlers receive `(event, responseStream, context)` and write directly to the response stream.
+
 Use the same handler locally, in Docker, or in a Fargate-style HTTP runtime:
 
 ```ts
 // server.ts
-import { server } from '@vyriy/server';
+import { streamServer } from '@vyriy/server';
 
 import { handler } from './handler.js';
 
-server(handler);
+streamServer(handler);
 ```
 
 Use the same handler in AWS Lambda response streaming:
@@ -83,24 +81,20 @@ import { handler } from './handler.js';
 export const main = awslambda.streamifyResponse(handler);
 ```
 
-That `handler.ts` shape is already streamified. For a standard non-streaming Lambda, export an `api(...)` handler directly without `streamify(...)` and without `responseStream`.
+That `handler.ts` shape already matches Lambda response streaming. For a standard non-streaming Lambda, export an `api(...)` handler directly without `responseStream`.
 
 You can also inline the same shape in one file when a separate local entrypoint is not needed:
 
 ```ts
-import { api, streamify } from '@vyriy/handler';
+import { streamApi } from '@vyriy/handler';
 
 export const main = awslambda.streamifyResponse(
-  streamify(
-    api(async (event, responseStream, context) => {
-      responseStream.setContentType?.('text/plain');
-      responseStream.write(`Request path: ${event.path}\n`);
-      responseStream.write(`Request id: ${context.awsRequestId}\n`);
-      responseStream.write('Part 1 of the response...');
-      responseStream.write('Part 2 of the response...');
-      responseStream.end();
-    }),
-  ),
+  streamApi(async (event, responseStream) => {
+    responseStream.setContentType?.('text/plain');
+    responseStream.write(`Request path: ${event.path}\n`);
+    responseStream.write('Part 1 of the response...');
+    responseStream.end('Part 2 of the response...');
+  }),
 );
 ```
 
@@ -141,15 +135,14 @@ export const handler = schedule(async (event) => {
 Compose a custom handler pipeline from individual helpers:
 
 ```ts
-import { compose, withChaos, withContext, withError, withLogger, withSmoke, withTimeout } from '@vyriy/handler';
+import { compose, withChaos, withContext, withError, withLogger, withTimeout } from '@vyriy/handler';
 
 export const handler = compose(
-  withError({ throwError: true }),
+  withError(),
   withLogger(),
   withChaos(),
   withTimeout(),
   withContext(),
-  withSmoke(),
 )(async (event) => {
   return {
     ok: true,
@@ -179,7 +172,7 @@ const withRequestId = factory<{ headerName?: string }>(async (handler, args, opt
 });
 
 export const handler = compose(
-  withError({ throwError: true }),
+  withError(),
   withLogger(),
   withTimeout(),
   withRequestId({
@@ -196,11 +189,9 @@ export const handler = compose(
 ## Prebuilt Chains
 
 - `api`
-  API Gateway chain with error handling, logging, timeout handling, context setup, smoke checks, healthcheck handling, default headers, CORS preflight handling, and structural support for streaming/static-file response results.
-- `streamifyApiResponse`
-  Adapts an `api(...)` handler that returns a streaming result to the three-argument handler shape expected by `awslambda.streamifyResponse`.
-- `streamify`
-  Alias for `streamifyApiResponse` intended for direct Lambda response streaming handlers.
+  API Gateway chain with error handling, logging, timeout handling, context setup, smoke checks, healthcheck handling, default headers, and CORS preflight handling.
+- `streamApi`
+  Response streaming API Gateway chain with the same wrapper behavior as `api`. Handlers receive `(event, responseStream, context)` and write directly to the Lambda response stream.
 
 - `schedule`
   EventBridge schedule chain with logging, timeout handling, context setup, smoke checks, and rethrown errors.
@@ -215,22 +206,18 @@ export const handler = compose(
 
 ### `withError(options?)`
 
-Catches handler failures, optionally runs an async error handler, and rethrows only when `throwError` is enabled.
+Catches handler failures, optionally runs a side-effect `errorHandler`, and rethrows the original error.
 
 Options:
 
 ```ts
 {
-  errorHandler?: (error: unknown) => Promise<void>;
-  throwError?: boolean;
+  errorHandler?: (error: unknown, args: HandlerParams<Event>) => Promise<void> | void;
 }
 ```
 
 - `errorHandler`
-  Async callback invoked with the caught error.
-
-- `throwError`
-  Re-throws the original error after `errorHandler` runs. Defaults to `false`.
+  Callback invoked with the caught error and handler arguments before the original error is rethrown.
 
 Example:
 
@@ -241,12 +228,15 @@ export const handler = withError({
   errorHandler: async (error) => {
     console.error('Handler failed:', error);
   },
-  throwError: true,
 })(async () => {
   throw new Error('boom');
 });
 ```
 
+### `withApiError(options?)`
+
+Catches API handler failures and converts them to an API Gateway result. Without a custom `errorHandler`, it returns a JSON `500`.
+
 ### `withLogger(options?)`
 
 Logs the incoming event and context, then logs either the result or the thrown error.
@@ -357,7 +347,7 @@ export const handler = withChaos({
 
 ### `withSmoke()`
 
-Returns the smoke response when the incoming event matches the smoke request payload.
+Returns the smoke response when the incoming event has `isSmoke: true`.
 
 Example:
 
@@ -374,16 +364,18 @@ export const handler = withSmoke()(async () => {
 });
 ```
 
+`withSmoke()` is used by the API, schedule, SNS, and SQS chains.
+
 ## Types
 
 The package also exports shared handler types:
 
 ```ts
-import type { Context, Decorator, Handler, Response } from '@vyriy/handler';
+import type { Context, Decorator, Handler, HandlerParams, Response } from '@vyriy/handler';
 ```
 
 ## Notes
 
 - `api` includes API-specific wrappers such as healthcheck handling, default headers, and CORS preflight handling
-- `schedule`, `sns`, and `sqs` enable `throwError: true` in `withError(...)`
-- `withSmoke()` delegates matching to `@vyriy/smoke`
+- `schedule`, `sns`, and `sqs` use `withError()` so failures are rethrown for event-source retry behavior
+- `withSmoke()` delegates matching to `@vyriy/smoke` and returns its API Gateway-compatible response

package/api.d.ts

@@ -1,7 +1,2 @@
-import type { ApiEvent, ApiResult, Context, Handler, ResponseStream } from './types.js';
-type ApiDecorator = {
-    (handler: Handler<ApiEvent, ApiResult | void, [context: Context]>): Handler<ApiEvent, ApiResult | void, [context: Context]>;
-    (handler: Handler<ApiEvent, ApiResult | void, [responseStream: ResponseStream, context: Context]>): Handler<ApiEvent, ApiResult | void, [responseStream: ResponseStream, context: Context]>;
-};
-export declare const api: ApiDecorator;
-export {};
+export declare const api: import("./types.js").Decorator<import("aws-lambda").APIGatewayProxyEvent, import("aws-lambda").APIGatewayProxyResult>;
+export declare const streamApi: import("./types.js").StreamDecorator<import("aws-lambda").APIGatewayProxyEvent>;

package/api.js

@@ -1,17 +1,24 @@
-import { compose } from './compose.js';
-import { withError } from './wrapper/error.js';
-import { withLogger } from './wrapper/logger.js';
-import { withTimeout } from './wrapper/timeout.js';
-import { withContext } from './wrapper/context.js';
-import { withSmoke } from './wrapper/smoke.js';
-import { withHealthcheck } from './wrapper/healthcheck.js';
-import { withHeaders } from './wrapper/headers.js';
-import { withCors } from './wrapper/cors.js';
-import { withChaos } from './wrapper/chaos.js';
-export const api = compose(withError(), withLogger(), withTimeout(), withContext(), withSmoke(), withHealthcheck(), withHeaders({
+import { compose, streamCompose } from './compose.js';
+import { streamWithApiError, withApiError } from './wrapper/error.js';
+import { streamWithLogger, withLogger } from './wrapper/logger.js';
+import { streamWithTimeout, withTimeout } from './wrapper/timeout.js';
+import { streamWithContext, withContext } from './wrapper/context.js';
+import { streamWithSmoke, withSmoke } from './wrapper/smoke.js';
+import { streamWithHealthcheck, withHealthcheck } from './wrapper/healthcheck.js';
+import { streamWithHeaders, withHeaders } from './wrapper/headers.js';
+import { streamWithCors, withCors } from './wrapper/cors.js';
+import { streamWithChaos, withChaos } from './wrapper/chaos.js';
+export const api = compose(withApiError(), withLogger(), withTimeout(), withContext(), withSmoke(), withHealthcheck(), withHeaders({
     'Access-Control-Allow-Origin': '*',
     'Access-Control-Allow-Methods': 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
     'Access-Control-Allow-Headers': 'Content-Type, Authorization, X-Requested-With, X-Api-Key, Accept, User-Agent, X-CSRF-Token',
     'Content-Type': 'application/json',
     'X-Robots-Tag': 'noindex, nofollow',
 }), withCors(), withChaos());
+export const streamApi = streamCompose(streamWithApiError(), streamWithLogger(), streamWithTimeout(), streamWithContext(), streamWithSmoke(), streamWithHealthcheck(), streamWithHeaders({
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Methods': 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type, Authorization, X-Requested-With, X-Api-Key, Accept, User-Agent, X-CSRF-Token',
+    'Content-Type': 'application/json',
+    'X-Robots-Tag': 'noindex, nofollow',
+}), streamWithCors(), streamWithChaos());

package/compose.d.ts

@@ -1,2 +1,3 @@
-import type { Compose } from './types.js';
+import type { Compose, StreamCompose } from './types.js';
 export declare const compose: Compose;
+export declare const streamCompose: StreamCompose;

package/compose.js

@@ -1 +1,2 @@
 export const compose = (...fns) => fns.reduceRight((prevDecorator, nextDecorator) => (handler) => nextDecorator(prevDecorator(handler)));
+export const streamCompose = (...fns) => fns.reduceRight((prevDecorator, nextDecorator) => (handler) => nextDecorator(prevDecorator(handler)));

package/factory.d.ts

@@ -1,4 +1,7 @@
 import type { Context } from 'aws-lambda';
-import type { Factory, HandlerArgs, HandlerParams } from './types.js';
-export declare const getContext: <Event, Args extends HandlerArgs>(args: HandlerParams<Event, Args>) => Context;
+import type { Factory, HandlerParams, ResponseStream, StreamFactory, StreamHandlerParams } from './types.js';
+export declare const getContext: <Event>(args: HandlerParams<Event>) => Context;
+export declare const getResponseStream: <Event>(args: StreamHandlerParams<Event>) => ResponseStream;
+export declare const getStreamContext: <Event>(args: StreamHandlerParams<Event>) => Context;
 export declare const factory: Factory;
+export declare const streamFactory: StreamFactory;

package/factory.js

@@ -1,3 +1,5 @@
-const createFactory = (wrapper) => (options) => (handler) => async (event, ...args) => wrapper(handler, [event, ...args], options);
-export const getContext = (args) => args.at(-1);
-export const factory = createFactory;
+export const getContext = (args) => args[1];
+export const getResponseStream = (args) => args[1];
+export const getStreamContext = (args) => args[2];
+export const factory = (wrapper) => (options) => (handler) => async (event, context) => wrapper(handler, [event, context], options);
+export const streamFactory = (wrapper) => (options) => (handler) => async (event, responseStream, context) => wrapper(handler, [event, responseStream, context], options);

package/index.d.ts

@@ -4,7 +4,6 @@ export * from './factory.js';
 export * from './schedule.js';
 export * from './sns.js';
 export * from './sqs.js';
-export * from './streamify.js';
 export * from './wrapper/context.js';
 export * from './wrapper/cors.js';
 export * from './wrapper/chaos.js';

package/index.js

@@ -4,7 +4,6 @@ export * from './factory.js';
 export * from './schedule.js';
 export * from './sns.js';
 export * from './sqs.js';
-export * from './streamify.js';
 export * from './wrapper/context.js';
 export * from './wrapper/cors.js';
 export * from './wrapper/chaos.js';

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@vyriy/handler",
-  "version": "0.3.0",
+  "version": "0.3.4",
   "description": "Composable AWS Lambda handler chains and wrappers for Vyriy projects",
   "type": "module",
   "main": "./index.js",
   "dependencies": {
     "@types/aws-lambda": "^8.10.161",
-    "@vyriy/chaos": "0.3.0",
-    "@vyriy/config": "0.3.0",
-    "@vyriy/logger": "0.3.0",
-    "@vyriy/smoke": "0.3.0",
-    "@vyriy/timeout": "0.3.0"
+    "@vyriy/chaos": "0.3.4",
+    "@vyriy/config": "0.3.4",
+    "@vyriy/logger": "0.3.4",
+    "@vyriy/smoke": "0.3.4",
+    "@vyriy/timeout": "0.3.4"
   },
   "agents": "./AGENTS.md",
   "license": "MIT",
@@ -96,16 +96,6 @@
       "import": "./sqs.js",
       "default": "./sqs.js"
     },
-    "./streamify": {
-      "types": "./streamify.d.ts",
-      "import": "./streamify.js",
-      "default": "./streamify.js"
-    },
-    "./streamify.js": {
-      "types": "./streamify.d.ts",
-      "import": "./streamify.js",
-      "default": "./streamify.js"
-    },
     "./wrapper/chaos": {
       "types": "./wrapper/chaos.d.ts",
       "import": "./wrapper/chaos.js",
@@ -186,6 +176,16 @@
       "import": "./wrapper/smoke.js",
       "default": "./wrapper/smoke.js"
     },
+    "./wrapper/stream": {
+      "types": "./wrapper/stream.d.ts",
+      "import": "./wrapper/stream.js",
+      "default": "./wrapper/stream.js"
+    },
+    "./wrapper/stream.js": {
+      "types": "./wrapper/stream.d.ts",
+      "import": "./wrapper/stream.js",
+      "default": "./wrapper/stream.js"
+    },
     "./wrapper/timeout": {
       "types": "./wrapper/timeout.d.ts",
       "import": "./wrapper/timeout.js",

package/schedule.d.ts

@@ -1,2 +1,2 @@
 import type { ScheduledEvent } from 'aws-lambda';
-export declare const schedule: import("./types.js").Decorator<ScheduledEvent<any>, void, [context: import("aws-lambda").Context]>;
+export declare const schedule: import("./types.js").Decorator<ScheduledEvent<any>, void>;

package/schedule.js

@@ -4,4 +4,4 @@ import { withLogger } from './wrapper/logger.js';
 import { withTimeout } from './wrapper/timeout.js';
 import { withContext } from './wrapper/context.js';
 import { withSmoke } from './wrapper/smoke.js';
-export const schedule = compose(withError({ throwError: true }), withLogger(), withTimeout(), withContext(), withSmoke());
+export const schedule = compose(withError(), withLogger(), withTimeout(), withContext(), withSmoke());

package/sns.d.ts

@@ -1,2 +1,2 @@
 import type { SNSEvent } from 'aws-lambda';
-export declare const sns: import("./types.js").Decorator<SNSEvent, void, [context: import("aws-lambda").Context]>;
+export declare const sns: import("./types.js").Decorator<SNSEvent, void>;

package/sns.js

@@ -4,4 +4,4 @@ import { withLogger } from './wrapper/logger.js';
 import { withTimeout } from './wrapper/timeout.js';
 import { withContext } from './wrapper/context.js';
 import { withSmoke } from './wrapper/smoke.js';
-export const sns = compose(withError({ throwError: true }), withLogger(), withTimeout(), withContext(), withSmoke());
+export const sns = compose(withError(), withLogger(), withTimeout(), withContext(), withSmoke());

package/sqs.d.ts

@@ -1,2 +1,2 @@
 import type { SQSEvent } from 'aws-lambda';
-export declare const sqs: import("./types.js").Decorator<SQSEvent, void, [context: import("aws-lambda").Context]>;
+export declare const sqs: import("./types.js").Decorator<SQSEvent, void>;

package/sqs.js

@@ -4,4 +4,4 @@ import { withLogger } from './wrapper/logger.js';
 import { withTimeout } from './wrapper/timeout.js';
 import { withContext } from './wrapper/context.js';
 import { withSmoke } from './wrapper/smoke.js';
-export const sqs = compose(withError({ throwError: true }), withLogger(), withTimeout(), withContext(), withSmoke());
+export const sqs = compose(withError(), withLogger(), withTimeout(), withContext(), withSmoke());

package/types.d.ts

@@ -9,26 +9,26 @@ export type ResponseStream = {
     writableEnded?: boolean;
     write(chunk: string | Buffer | Uint8Array): unknown;
 };
-export type StreamWriter = (responseStream: ResponseStream) => Promise<void> | void;
-export type StreamResult = Omit<Partial<APIGatewayProxyResult>, 'body'> & {
-    stream: StreamWriter;
-    body?: never;
-};
-export type StaticFileResult = Omit<Partial<APIGatewayProxyResult>, 'body'> & {
-    filePath: string;
-    body?: never;
-};
-export type ApiResult = APIGatewayProxyResult | StaticFileResult | StreamResult;
+export type ApiResult = APIGatewayProxyResult;
 export type ApiEvent = APIGatewayProxyEvent;
-export type HandlerArgs = [...args: unknown[], context: Context];
-export type HandlerParams<Event, Args extends HandlerArgs = [context: Context]> = [event: Event, ...args: Args];
+export type HandlerParams<Event> = [event: Event, context: Context];
+export type StreamHandlerParams<Event> = [event: Event, responseStream: ResponseStream, context: Context];
 export type Response<Result> = Promise<Result>;
-export type Handler<Event, Result, Args extends HandlerArgs = [context: Context]> = (event: Event, ...args: Args) => Response<Result>;
-export type Decorator<Event, Result, Args extends HandlerArgs = [context: Context]> = (handler: Handler<Event, Result, Args>) => Handler<Event, Result, Args>;
-export type Compose = <Event, Result, Args extends HandlerArgs = [context: Context]>(...decorators: Array<Decorator<Event, Result, Args>>) => Decorator<Event, Result, Args>;
-export type Wrapper<Options> = <Event, Result, Args extends HandlerArgs = [context: Context]>(handler: Handler<Event, Result, Args>, args: HandlerParams<Event, Args>, options?: Options) => Response<Result>;
-export type TypedWrapper<Event, Result, Options, Args extends HandlerArgs = [context: Context]> = (handler: Handler<Event, Result, Args>, args: HandlerParams<Event, Args>, options?: Options) => Response<Result>;
+export type Handler<Event, Result> = (event: Event, context: Context) => Response<Result>;
+export type StreamHandler<Event> = (event: Event, responseStream: ResponseStream, context: Context) => Response<void>;
+export type Decorator<Event, Result> = (handler: Handler<Event, Result>) => Handler<Event, Result>;
+export type StreamDecorator<Event> = (handler: StreamHandler<Event>) => StreamHandler<Event>;
+export type Compose = <Event, Result>(...decorators: Array<Decorator<Event, Result>>) => Decorator<Event, Result>;
+export type StreamCompose = <Event>(...decorators: Array<StreamDecorator<Event>>) => StreamDecorator<Event>;
+export type Wrapper<Options> = <Event, Result>(handler: Handler<Event, Result>, args: HandlerParams<Event>, options?: Options) => Response<Result>;
+export type StreamWrapper<Options> = <Event>(handler: StreamHandler<Event>, args: StreamHandlerParams<Event>, options?: Options) => Response<void>;
+export type TypedWrapper<Event, Result, Options> = (handler: Handler<Event, Result>, args: HandlerParams<Event>, options?: Options) => Response<Result>;
+export type StreamTypedWrapper<Event, Options> = (handler: StreamHandler<Event>, args: StreamHandlerParams<Event>, options?: Options) => Response<void>;
 export type Factory = {
-    <Options = undefined>(wrapper: Wrapper<Options>): <Event, Result, Args extends HandlerArgs = [context: Context]>(options?: Options) => Decorator<Event, Result, Args>;
-    <Options, Event, Result, Args extends HandlerArgs = [context: Context]>(wrapper: TypedWrapper<Event, Result, Options, Args>): (options?: Options) => Decorator<Event, Result, Args>;
+    <Options = undefined>(wrapper: Wrapper<Options>): <Event, Result>(options?: Options) => Decorator<Event, Result>;
+    <Options, Event, Result>(wrapper: TypedWrapper<Event, Result, Options>): (options?: Options) => Decorator<Event, Result>;
+};
+export type StreamFactory = {
+    <Options = undefined>(wrapper: StreamWrapper<Options>): <Event>(options?: Options) => StreamDecorator<Event>;
+    <Options, Event>(wrapper: StreamTypedWrapper<Event, Options>): (options?: Options) => StreamDecorator<Event>;
 };

package/wrapper/chaos.d.ts

@@ -1,2 +1,3 @@
 import { type ChaosOptions } from '@vyriy/chaos';
-export declare const withChaos: <Event, Result, Args extends import("../types.js").HandlerArgs = [context: import("aws-lambda").Context]>(options?: ChaosOptions | undefined) => import("../types.js").Decorator<Event, Result, Args>;
+export declare const withChaos: <Event, Result>(options?: ChaosOptions | undefined) => import("../types.js").Decorator<Event, Result>;
+export declare const streamWithChaos: <Event>(options?: ChaosOptions | undefined) => import("../types.js").StreamDecorator<Event>;

package/wrapper/chaos.js

@@ -1,6 +1,6 @@
 import { chaos } from '@vyriy/chaos';
 import { getConfig } from '@vyriy/config';
-import { factory } from '../factory.js';
+import { factory, streamFactory } from '../factory.js';
 const getChaosEnabled = () => getConfig('CHAOS_ENABLED', false, 'boolean');
 const getChaosErrorEnabled = () => getConfig('CHAOS_ERROR_ENABLED', true, 'boolean');
 const getChaosTimeoutEnabled = () => getConfig('CHAOS_TIMEOUT_ENABLED', true, 'boolean');
@@ -33,3 +33,14 @@ export const withChaos = factory(async (handler, args, options = {}) => {
     });
     return handler(...args);
 });
+export const streamWithChaos = streamFactory(async (handler, args, options = {}) => {
+    const enabled = options.enabled ?? getChaosEnabled();
+    const strategy = getStrategy(options);
+    await chaos({
+        ...options,
+        enabled: enabled && (strategy !== 'random' || getChaosErrorEnabled() || getChaosTimeoutEnabled()),
+        strategy,
+        timeoutMs: options.timeoutMs ?? getChaosTimeoutMs(),
+    });
+    return handler(...args);
+});

package/wrapper/context.d.ts

@@ -1 +1,2 @@
-export declare const withContext: <Event, Result, Args extends import("../types.js").HandlerArgs = [context: import("aws-lambda").Context]>(options?: undefined) => import("../types.js").Decorator<Event, Result, Args>;
+export declare const withContext: <Event, Result>(options?: undefined) => import("../types.js").Decorator<Event, Result>;
+export declare const streamWithContext: <Event>(options?: undefined) => import("../types.js").StreamDecorator<Event>;

package/wrapper/context.js

@@ -1,6 +1,11 @@
-import { factory, getContext } from '../factory.js';
+import { factory, getContext, getStreamContext, streamFactory } from '../factory.js';
 export const withContext = factory(async (handler, args) => {
     const ctx = getContext(args);
     ctx.callbackWaitsForEmptyEventLoop = false;
     return handler(...args);
 });
+export const streamWithContext = streamFactory(async (handler, args) => {
+    const ctx = getStreamContext(args);
+    ctx.callbackWaitsForEmptyEventLoop = false;
+    return handler(...args);
+});

package/wrapper/cors.d.ts

@@ -1,2 +1,2 @@
-import type { ApiResult, HandlerArgs } from '../types.js';
-export declare const withCors: (options?: undefined) => import("../types.js").Decorator<import("aws-lambda").APIGatewayProxyEvent, void | ApiResult, HandlerArgs>;
+export declare const withCors: (options?: unknown) => import("../types.js").Decorator<import("aws-lambda").APIGatewayProxyEvent, import("aws-lambda").APIGatewayProxyResult>;
+export declare const streamWithCors: (options?: unknown) => import("../types.js").StreamDecorator<import("aws-lambda").APIGatewayProxyEvent>;

package/wrapper/cors.js

@@ -1,4 +1,5 @@
-import { factory } from '../factory.js';
+import { factory, streamFactory } from '../factory.js';
+import { responseStream } from './stream.js';
 export const withCors = factory(async (handler, args) => {
     const [request] = args;
     if (request.httpMethod === 'OPTIONS') {
@@ -9,3 +10,11 @@ export const withCors = factory(async (handler, args) => {
     }
     return handler(...args);
 });
+export const streamWithCors = streamFactory(async (handler, args) => {
+    const [request, stream] = args;
+    if (request.httpMethod === 'OPTIONS') {
+        responseStream(stream, { statusCode: 204 }).end();
+        return;
+    }
+    await handler(...args);
+});

package/wrapper/error.d.ts

@@ -1,5 +1,12 @@
-export type ErrorOptions = {
-    errorHandler?: (err: unknown) => Promise<void>;
-    throwError?: boolean;
+import type { ApiEvent, ApiResult, Decorator, HandlerParams, StreamDecorator, StreamHandlerParams } from '../types.js';
+export type ErrorHandler<Params extends unknown[]> = (err: unknown, args: Params) => Promise<void> | void;
+export type ApiErrorHandler<Params extends unknown[], Result> = (err: unknown, args: Params) => Promise<Result> | Result;
+export type ErrorOptions<Params extends unknown[]> = {
+    errorHandler?: ErrorHandler<Params>;
 };
-export declare const withError: <Event, Result, Args extends import("../types.js").HandlerArgs = [context: import("aws-lambda").Context]>(options?: ErrorOptions | undefined) => import("../types.js").Decorator<Event, Result, Args>;
+export type ApiErrorOptions<Params extends unknown[], Result> = {
+    errorHandler?: ApiErrorHandler<Params, Result>;
+};
+export declare const withError: <Event, Result>(options?: ErrorOptions<HandlerParams<Event>>) => Decorator<Event, Result>;
+export declare const withApiError: (options?: ApiErrorOptions<HandlerParams<ApiEvent>, ApiResult>) => Decorator<ApiEvent, ApiResult>;
+export declare const streamWithApiError: (options?: ApiErrorOptions<StreamHandlerParams<ApiEvent>, ApiResult | void>) => StreamDecorator<ApiEvent>;

package/wrapper/error.js

@@ -1,17 +1,42 @@
-import { factory } from '../factory.js';
-export const withError = factory(async (handler, args, options = {}) => {
-    const { errorHandler, throwError = false } = options;
-    let result;
+import { STATUS_CODES } from 'node:http';
+import { responseStream } from './stream.js';
+const defaultErrorResult = () => ({
+    statusCode: 500,
+    headers: {
+        'content-type': 'application/json',
+    },
+    body: JSON.stringify({
+        message: STATUS_CODES[500],
+    }),
+});
+export const withError = (options = {}) => (handler) => async (event, context) => {
     try {
-        result = await handler(...args);
+        return await handler(event, context);
     }
     catch (err) {
-        if (errorHandler) {
-            await errorHandler(err);
-        }
-        if (throwError) {
-            throw err;
+        await options.errorHandler?.(err, [event, context]);
+        throw err;
+    }
+};
+export const withApiError = (options = {}) => (handler) => async (event, context) => {
+    try {
+        return await handler(event, context);
+    }
+    catch (err) {
+        return options.errorHandler?.(err, [event, context]) ?? defaultErrorResult();
+    }
+};
+export const streamWithApiError = (options = {}) => (handler) => async (event, stream, context) => {
+    try {
+        await handler(event, stream, context);
+    }
+    catch (err) {
+        const result = (await options.errorHandler?.(err, [event, stream, context])) ?? defaultErrorResult();
+        if (result) {
+            responseStream(stream, {
+                headers: result.headers,
+                statusCode: result.statusCode,
+            }).end(result.body);
         }
     }
-    return result;
-});
+};

package/wrapper/headers.d.ts

@@ -1,2 +1,2 @@
-import type { ApiResult, HandlerArgs } from '../types.js';
-export declare const withHeaders: (options?: Record<string, string> | undefined) => import("../types.js").Decorator<import("aws-lambda").APIGatewayProxyEvent, void | ApiResult, HandlerArgs>;
+export declare const withHeaders: (options?: Record<string, string> | undefined) => import("../types.js").Decorator<import("aws-lambda").APIGatewayProxyEvent, import("aws-lambda").APIGatewayProxyResult>;
+export declare const streamWithHeaders: (options?: Record<string, string> | undefined) => import("../types.js").StreamDecorator<import("aws-lambda").APIGatewayProxyEvent>;

package/wrapper/headers.js

@@ -1,12 +1,17 @@
-import { factory } from '../factory.js';
-export const withHeaders = factory(async (handler, args, options = {}) => {
-    const result = await handler(...args);
-    if (!result) {
-        return result;
-    }
+import { factory, streamFactory } from '../factory.js';
+import { responseStream } from './stream.js';
+const mergeHeaders = (result, options) => {
     result.headers = {
         ...options,
         ...result.headers,
     };
     return result;
+};
+export const withHeaders = factory(async (handler, args, options = {}) => {
+    const result = await handler(...args);
+    return mergeHeaders(result, options);
+});
+export const streamWithHeaders = streamFactory(async (handler, args, options = {}) => {
+    const [event, stream, context] = args;
+    await handler(event, responseStream(stream, { headers: options }), context);
 });

package/wrapper/healthcheck.d.ts

@@ -1,5 +1,9 @@
-import type { ApiResult, HandlerArgs } from '../types.js';
-export declare const withHealthcheck: (options?: {
+export type HealthcheckOptions = {
     path?: string;
     action?: () => Promise<void>;
-} | undefined) => import("../types.js").Decorator<import("aws-lambda").APIGatewayProxyEvent, void | ApiResult, HandlerArgs>;
+};
+export declare const withHealthcheck: (options?: HealthcheckOptions | undefined) => import("../types.js").Decorator<import("aws-lambda").APIGatewayProxyEvent, import("aws-lambda").APIGatewayProxyResult | {
+    statusCode: number;
+    body: string;
+}>;
+export declare const streamWithHealthcheck: (options?: HealthcheckOptions | undefined) => import("../types.js").StreamDecorator<import("aws-lambda").APIGatewayProxyEvent>;

package/wrapper/healthcheck.js

@@ -1,18 +1,32 @@
 import { STATUS_CODES } from 'node:http';
-import { factory } from '../factory.js';
+import { factory, streamFactory } from '../factory.js';
+import { responseStream } from './stream.js';
+const getHealthcheckResult = async (event, options = {}) => {
+    const { path = '/healthcheck', action } = options;
+    if (event.path !== path) {
+        return undefined;
+    }
+    if (action) {
+        await action();
+    }
+    return {
+        statusCode: 200,
+        body: JSON.stringify({
+            message: STATUS_CODES[200],
+        }),
+    };
+};
 export const withHealthcheck = factory(async (handler, args, options = {}) => {
     const [event] = args;
-    const { path = '/healthcheck', action } = options;
-    if (event.path === path) {
-        if (action) {
-            await action();
-        }
-        return {
-            statusCode: 200,
-            body: JSON.stringify({
-                message: STATUS_CODES[200],
-            }),
-        };
+    const result = await getHealthcheckResult(event, options);
+    return result ?? handler(...args);
+});
+export const streamWithHealthcheck = streamFactory(async (handler, args, options = {}) => {
+    const [event, stream] = args;
+    const result = await getHealthcheckResult(event, options);
+    if (result) {
+        responseStream(stream, { statusCode: result.statusCode }).end(result.body);
+        return;
     }
-    return handler(...args);
+    await handler(...args);
 });

package/wrapper/logger.d.ts

@@ -1,4 +1,5 @@
 export type LoggerOptions = {
     logger?: typeof console;
 };
-export declare const withLogger: <Event, Result, Args extends import("../types.js").HandlerArgs = [context: import("aws-lambda").Context]>(options?: LoggerOptions | undefined) => import("../types.js").Decorator<Event, Result, Args>;
+export declare const withLogger: <Event, Result>(options?: LoggerOptions | undefined) => import("../types.js").Decorator<Event, Result>;
+export declare const streamWithLogger: <Event>(options?: LoggerOptions | undefined) => import("../types.js").StreamDecorator<Event>;

package/wrapper/logger.js

@@ -1,5 +1,5 @@
 import { createLogger } from '@vyriy/logger';
-import { factory, getContext } from '../factory.js';
+import { factory, getContext, getStreamContext, streamFactory } from '../factory.js';
 export const withLogger = factory(async (handler, args, options = {}) => {
     const { logger = createLogger() } = options;
     const [event] = args;
@@ -19,3 +19,21 @@ export const withLogger = factory(async (handler, args, options = {}) => {
         throw error;
     }
 });
+export const streamWithLogger = streamFactory(async (handler, args, options = {}) => {
+    const { logger = createLogger() } = options;
+    const [event] = args;
+    const context = getStreamContext(args);
+    logger.info('Event:', event);
+    logger.info('Context:', context);
+    try {
+        await handler(...args);
+        logger.info('Result:', undefined);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            logger.error('Error:', error.message);
+        }
+        logger.error(error);
+        throw error;
+    }
+});

package/wrapper/smoke.d.ts

@@ -1,2 +1,3 @@
-import type { Context, Decorator, HandlerArgs } from '../types.js';
-export declare const withSmoke: <Event, Result, Args extends HandlerArgs = [context: Context]>() => Decorator<Event, Result, Args>;
+import type { ApiResult, Decorator, StreamDecorator } from '../types.js';
+export declare const withSmoke: <Event, Result extends ApiResult | void = ApiResult>() => Decorator<Event, Result>;
+export declare const streamWithSmoke: <Event>() => StreamDecorator<Event>;

package/wrapper/smoke.js

@@ -1,4 +1,17 @@
 import { smoke } from '@vyriy/smoke';
-import { factory } from '../factory.js';
-const smokeWrapper = async (handler, args) => smoke(args[0]) || handler(...args);
-export const withSmoke = factory(smokeWrapper);
+import { responseStream } from './stream.js';
+export const withSmoke = () => (handler) => async (event, context) => {
+    const result = smoke(event);
+    return (result || (await handler(event, context)));
+};
+export const streamWithSmoke = () => (handler) => async (event, stream, context) => {
+    const result = smoke(event);
+    if (result) {
+        responseStream(stream, {
+            headers: result.headers,
+            statusCode: result.statusCode,
+        }).end(result.body);
+        return;
+    }
+    await handler(event, stream, context);
+};

package/wrapper/stream.d.ts

@@ -0,0 +1,6 @@
+import type { ApiResult, ResponseStream } from '../types.js';
+export type StreamMetadata = {
+    headers?: ApiResult['headers'];
+    statusCode?: ApiResult['statusCode'];
+};
+export declare const responseStream: (stream: ResponseStream, metadata?: StreamMetadata) => ResponseStream;

package/wrapper/stream.js

@@ -0,0 +1,15 @@
+const getContentType = (headers) => headers?.['content-type'] ?? headers?.['Content-Type'];
+export const responseStream = (stream, metadata = {}) => {
+    const runtimeStream = globalThis.awslambda?.HttpResponseStream?.from?.(stream, {
+        headers: metadata.headers,
+        statusCode: metadata.statusCode ?? 200,
+    });
+    if (runtimeStream) {
+        return runtimeStream;
+    }
+    const contentType = getContentType(metadata.headers);
+    if (contentType) {
+        stream.setContentType?.(String(contentType));
+    }
+    return stream;
+};

package/wrapper/timeout.d.ts

@@ -1 +1,2 @@
-export declare const withTimeout: <Event, Result, Args extends import("../types.js").HandlerArgs = [context: import("aws-lambda").Context]>(options?: undefined) => import("../types.js").Decorator<Event, Result, Args>;
+export declare const withTimeout: <Event, Result>(options?: undefined) => import("../types.js").Decorator<Event, Result>;
+export declare const streamWithTimeout: <Event>(options?: undefined) => import("../types.js").StreamDecorator<Event>;

package/wrapper/timeout.js

@@ -1,6 +1,10 @@
 import { timeout as error } from '@vyriy/timeout';
-import { factory, getContext } from '../factory.js';
+import { factory, getContext, getStreamContext, streamFactory } from '../factory.js';
 export const withTimeout = factory(async (handler, args) => Promise.race([
     error(getContext(args).getRemainingTimeInMillis() - 1000),
     handler(...args),
 ]));
+export const streamWithTimeout = streamFactory(async (handler, args) => Promise.race([
+    error(getStreamContext(args).getRemainingTimeInMillis() - 1000),
+    handler(...args),
+]));

package/streamify.d.ts

@@ -1,9 +0,0 @@
-import type { Context } from 'aws-lambda';
-import type { ApiEvent, ApiResult, Handler, ResponseStream } from './types.js';
-type LambdaResponseStream = ResponseStream & {
-    setContentType?: (contentType: string) => void;
-};
-export type StreamifiedApiHandler = (event: ApiEvent, responseStream: LambdaResponseStream, context: Context) => Promise<void>;
-export declare const streamifyApiResponse: (handler: Handler<ApiEvent, ApiResult | void, [context: Context]>) => StreamifiedApiHandler;
-export declare const streamify: (handler: Handler<ApiEvent, ApiResult | void, [responseStream: ResponseStream, context: Context]>) => StreamifiedApiHandler;
-export {};

package/streamify.js

@@ -1,33 +0,0 @@
-const getLambdaResponseStream = (responseStream, result) => {
-    const response = globalThis.awslambda?.HttpResponseStream?.from?.(responseStream, {
-        headers: result.headers,
-        statusCode: result.statusCode ?? 200,
-    });
-    return response ?? responseStream;
-};
-const isStreamResult = (result) => 'stream' in result && typeof result.stream === 'function';
-const writeResult = async (responseStream, result) => {
-    if (!result) {
-        if (!responseStream.writableEnded) {
-            responseStream.end();
-        }
-        return;
-    }
-    const stream = getLambdaResponseStream(responseStream, result);
-    if (isStreamResult(result)) {
-        await result.stream(stream);
-        return;
-    }
-    if ('body' in result && result.body !== undefined) {
-        stream.write(result.body);
-    }
-    stream.end();
-};
-export const streamifyApiResponse = (handler) => async (event, responseStream, context) => {
-    const result = await handler(event, context);
-    await writeResult(responseStream, result);
-};
-export const streamify = (handler) => async (event, responseStream, context) => {
-    const result = await handler(event, responseStream, context);
-    await writeResult(responseStream, result);
-};