@taserjs/router 0.0.0

package/dist/esm/middleware/secure-headers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"secure-headers.js","names":[],"sources":["../../../src/middleware/secure-headers.ts"],"sourcesContent":["import { secureHeaders as honoSecureHeaders } from 'hono/secure-headers'\n\nimport { wrapHonoMiddleware } from './auth.js'\n\nconst honoSecureHeadersMiddleware = wrapHonoMiddleware(honoSecureHeaders)\n\nexport function secureHeaders(...args: Parameters<typeof honoSecureHeaders>) {\n  return honoSecureHeadersMiddleware(...args)\n}\n\nexport type SecureHeadersOptions = NonNullable<Parameters<typeof honoSecureHeaders>[0]>\n"],"mappings":";;;AAIA,IAAM,8BAA8B,mBAAmB,eAAiB;AAExE,SAAgB,cAAc,GAAG,MAA4C;CAC3E,OAAO,4BAA4B,GAAG,IAAI;AAC5C"}

package/dist/esm/middleware/timing.d.ts

@@ -0,0 +1,3 @@
+import { timing as honoTiming } from 'hono/timing';
+export declare function timing(...args: Parameters<typeof honoTiming>): import('../types/units.js').MiddlewareUnit<import('../types/units.js').MiddlewareReturnFromParts<unknown, unknown, unknown, {}>>;
+export type TimingOptions = NonNullable<Parameters<typeof honoTiming>[0]>;

package/dist/esm/middleware/timing.js

@@ -0,0 +1,11 @@
+import { wrapHonoMiddleware } from "./auth.js";
+import { timing as timing$1 } from "hono/timing";
+//#region src/middleware/timing.ts
+var honoTimingMiddleware = wrapHonoMiddleware(timing$1);
+function timing(...args) {
+	return honoTimingMiddleware(...args);
+}
+//#endregion
+export { timing };
+
+//# sourceMappingURL=timing.js.map

package/dist/esm/middleware/timing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timing.js","names":[],"sources":["../../../src/middleware/timing.ts"],"sourcesContent":["import { timing as honoTiming } from 'hono/timing'\n\nimport { wrapHonoMiddleware } from './auth.js'\n\nconst honoTimingMiddleware = wrapHonoMiddleware(honoTiming)\n\nexport function timing(...args: Parameters<typeof honoTiming>) {\n  return honoTimingMiddleware(...args)\n}\n\nexport type TimingOptions = NonNullable<Parameters<typeof honoTiming>[0]>\n"],"mappings":";;;AAIA,IAAM,uBAAuB,mBAAmB,QAAU;AAE1D,SAAgB,OAAO,GAAG,MAAqC;CAC7D,OAAO,qBAAqB,GAAG,IAAI;AACrC"}

package/dist/esm/middleware.d.ts

@@ -0,0 +1,2 @@
+import { LayoutId, MiddlewareBuilder } from './types/index.js';
+export declare function createMiddleware<const Layout extends LayoutId>(layout: Layout): MiddlewareBuilder<Layout, readonly []>;

package/dist/esm/middleware.js

@@ -0,0 +1,17 @@
+//#region src/middleware.ts
+function createMiddleware(layout) {
+	const entries = [];
+	const chain = {
+		layout,
+		middlewares: entries,
+		use(definition) {
+			entries.push(definition);
+			return chain;
+		}
+	};
+	return chain;
+}
+//#endregion
+export { createMiddleware };
+
+//# sourceMappingURL=middleware.js.map

package/dist/esm/middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.js","names":[],"sources":["../../src/middleware.ts"],"sourcesContent":["import type { LayoutId, MiddlewareBuilder } from './types/index.js'\nimport type { MiddlewareDefinition } from './types/units.js'\n\nexport function createMiddleware<const Layout extends LayoutId>(\n  layout: Layout,\n): MiddlewareBuilder<Layout, readonly []> {\n  const entries: MiddlewareDefinition[] = []\n\n  const chain = {\n    layout,\n    middlewares: entries,\n    use(definition: MiddlewareDefinition) {\n      entries.push(definition)\n      return chain\n    },\n  }\n\n  return chain as unknown as MiddlewareBuilder<Layout, readonly []>\n}\n"],"mappings":";AAGA,SAAgB,iBACd,QACwC;CACxC,MAAM,UAAkC,CAAC;CAEzC,MAAM,QAAQ;EACZ;EACA,aAAa;EACb,IAAI,YAAkC;GACpC,QAAQ,KAAK,UAAU;GACvB,OAAO;EACT;CACF;CAEA,OAAO;AACT"}

package/dist/esm/register.d.ts

@@ -0,0 +1,2 @@
+export interface RouterRegister {
+}

package/dist/esm/route.d.ts

@@ -0,0 +1,5 @@
+import { Method, RouteBuilder, RoutePath, ValidatorParts } from './types/index.js';
+import { HttpMethod } from './types/units.js';
+import { SchemaValidators } from './define/validators.js';
+/** Shared internal builder — not part of the public `@taserjs/router` API. */
+export declare function createRouteBuilder(path: string, method: HttpMethod | 'ANY' | 'ALL', validators?: SchemaValidators, methods?: readonly HttpMethod[]): RouteBuilder<RoutePath, Method, readonly [], ValidatorParts>;

package/dist/esm/route.js

@@ -0,0 +1,94 @@
+import { isHandlerUnit } from "./types/units.js";
+import { HANDLER_SCHEMA_KEY_MAP } from "./constants.js";
+import { pickDefinedSchemas } from "./define/validators.js";
+import { collectReturnsFromDefinitions, hasInputSchemas, mergeReturnsMaps, withAuto422 } from "@taserjs/router-utils";
+//#region src/route.ts
+function toUtilsMap(map) {
+	if (!map) return {};
+	const out = {};
+	for (const [key, schema] of Object.entries(map)) if (schema !== void 0) out[Number(key)] = schema;
+	return out;
+}
+function buildEffectiveReturns(args) {
+	const with422 = withAuto422(mergeReturnsMaps(toUtilsMap(args.middlewareReturns), toUtilsMap(args.routeReturns), toUtilsMap(args.handlerMiddlewareReturns), toUtilsMap(args.handlerReturns)), hasInputSchemas(args.schemas));
+	return Object.keys(with422).length > 0 ? with422 : void 0;
+}
+function buildRouteBase(path, method, methods, middlewares) {
+	return {
+		path,
+		method,
+		...methods ? { methods: [...methods] } : {},
+		middlewares: [...middlewares]
+	};
+}
+/** Shared internal builder — not part of the public `@taserjs/router` API. */
+function createRouteBuilder(path, method, validators = {}, methods) {
+	const middlewares = [];
+	let routeReturns = {};
+	const builder = {
+		path,
+		method,
+		returns(map) {
+			routeReturns = {
+				...routeReturns,
+				...toUtilsMap(map)
+			};
+			return builder;
+		},
+		use(definition) {
+			middlewares.push(definition);
+			return builder;
+		},
+		handler(fnOrUnit) {
+			const routeSchemas = pickDefinedSchemas(validators);
+			const base = buildRouteBase(path, method, methods, middlewares);
+			if (isHandlerUnit(fnOrUnit)) {
+				const handlerSchemas = pickDefinedSchemas(fnOrUnit, HANDLER_SCHEMA_KEY_MAP);
+				const returns = buildEffectiveReturns({
+					middlewareReturns: collectReturnsFromDefinitions(middlewares),
+					routeReturns,
+					handlerMiddlewareReturns: collectReturnsFromDefinitions(fnOrUnit.middlewares),
+					handlerReturns: fnOrUnit.returns,
+					schemas: {
+						...validators,
+						handlerQuery: fnOrUnit.query,
+						handlerParams: fnOrUnit.params,
+						handlerBody: fnOrUnit.body,
+						middlewares,
+						handlerMiddlewares: fnOrUnit.middlewares
+					}
+				});
+				return {
+					...base,
+					handlerMiddlewares: [...fnOrUnit.middlewares],
+					handler: fnOrUnit.handler,
+					...routeSchemas,
+					...handlerSchemas,
+					...returns ? { returns } : {}
+				};
+			}
+			const returns = buildEffectiveReturns({
+				middlewareReturns: collectReturnsFromDefinitions(middlewares),
+				routeReturns,
+				handlerMiddlewareReturns: {},
+				handlerReturns: void 0,
+				schemas: {
+					...validators,
+					middlewares
+				}
+			});
+			return {
+				...base,
+				handlerMiddlewares: [],
+				handler: fnOrUnit,
+				...routeSchemas,
+				...returns ? { returns } : {}
+			};
+		}
+	};
+	return builder;
+}
+//#endregion
+export { createRouteBuilder };
+
+//# sourceMappingURL=route.js.map

package/dist/esm/route.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.js","names":[],"sources":["../../src/route.ts"],"sourcesContent":["import type { StandardSchemaV1 } from '@standard-schema/spec'\nimport {\n  collectReturnsFromDefinitions,\n  hasInputSchemas,\n  mergeReturnsMaps,\n  withAuto422,\n} from '@taserjs/router-utils'\n\nimport type { Method, RouteBuilder, RoutePath, ReturnsMap, ValidatorParts } from './types/index.js'\nimport type { HttpMethod, MiddlewareDefinition } from './types/units.js'\nimport { isHandlerUnit } from './types/units.js'\nimport { HANDLER_SCHEMA_KEY_MAP } from './constants.js'\nimport {\n  pickDefinedSchemas,\n  type SchemaValidators,\n} from './define/validators.js'\n\nfunction toUtilsMap(map: ReturnsMap | undefined): Record<number, StandardSchemaV1> {\n  if (!map) {\n    return {}\n  }\n  const out: Record<number, StandardSchemaV1> = {}\n  for (const [key, schema] of Object.entries(map)) {\n    if (schema !== undefined) {\n      out[Number(key)] = schema\n    }\n  }\n  return out\n}\n\nfunction buildEffectiveReturns(args: {\n  middlewareReturns: ReturnsMap\n  routeReturns: ReturnsMap\n  handlerMiddlewareReturns: ReturnsMap\n  handlerReturns: ReturnsMap | undefined\n  schemas: {\n    query?: unknown\n    params?: unknown\n    body?: unknown\n    handlerQuery?: unknown\n    handlerParams?: unknown\n    handlerBody?: unknown\n    middlewares?: readonly MiddlewareDefinition[]\n    handlerMiddlewares?: readonly MiddlewareDefinition[]\n  }\n}): Record<number, StandardSchemaV1> | undefined {\n  const merged = mergeReturnsMaps(\n    toUtilsMap(args.middlewareReturns),\n    toUtilsMap(args.routeReturns),\n    toUtilsMap(args.handlerMiddlewareReturns),\n    toUtilsMap(args.handlerReturns),\n  )\n  const with422 = withAuto422(merged, hasInputSchemas(args.schemas))\n  return Object.keys(with422).length > 0 ? with422 : undefined\n}\n\nfunction buildRouteBase(\n  path: string,\n  method: HttpMethod | 'ANY' | 'ALL',\n  methods: readonly HttpMethod[] | undefined,\n  middlewares: MiddlewareDefinition[],\n) {\n  return {\n    path,\n    method,\n    ...(methods ? { methods: [...methods] } : {}),\n    middlewares: [...middlewares],\n  }\n}\n\n/** Shared internal builder — not part of the public `@taserjs/router` API. */\nexport function createRouteBuilder(\n  path: string,\n  method: HttpMethod | 'ANY' | 'ALL',\n  validators: SchemaValidators = {},\n  methods?: readonly HttpMethod[],\n): RouteBuilder<RoutePath, Method, readonly [], ValidatorParts> {\n  const middlewares: MiddlewareDefinition[] = []\n  let routeReturns: Record<number, StandardSchemaV1> = {}\n\n  const builder = {\n    path,\n    method,\n    returns(map: ReturnsMap) {\n      routeReturns = { ...routeReturns, ...toUtilsMap(map) }\n      return builder\n    },\n    use(definition: MiddlewareDefinition) {\n      middlewares.push(definition)\n      return builder\n    },\n    handler(fnOrUnit: ((ctx: unknown) => unknown) | unknown) {\n      const routeSchemas = pickDefinedSchemas(validators)\n      const base = buildRouteBase(path, method, methods, middlewares)\n\n      if (isHandlerUnit(fnOrUnit)) {\n        const handlerSchemas = pickDefinedSchemas(fnOrUnit, HANDLER_SCHEMA_KEY_MAP)\n        const returns = buildEffectiveReturns({\n          middlewareReturns: collectReturnsFromDefinitions(middlewares),\n          routeReturns: routeReturns,\n          handlerMiddlewareReturns: collectReturnsFromDefinitions(fnOrUnit.middlewares),\n          handlerReturns: fnOrUnit.returns,\n          schemas: {\n            ...validators,\n            handlerQuery: fnOrUnit.query,\n            handlerParams: fnOrUnit.params,\n            handlerBody: fnOrUnit.body,\n            middlewares,\n            handlerMiddlewares: fnOrUnit.middlewares,\n          },\n        })\n\n        return {\n          ...base,\n          handlerMiddlewares: [...fnOrUnit.middlewares],\n          handler: fnOrUnit.handler,\n          ...routeSchemas,\n          ...handlerSchemas,\n          ...(returns ? { returns } : {}),\n        }\n      }\n\n      const returns = buildEffectiveReturns({\n        middlewareReturns: collectReturnsFromDefinitions(middlewares),\n        routeReturns: routeReturns,\n        handlerMiddlewareReturns: {},\n        handlerReturns: undefined,\n        schemas: {\n          ...validators,\n          middlewares,\n        },\n      })\n\n      return {\n        ...base,\n        handlerMiddlewares: [],\n        handler: fnOrUnit as (ctx: unknown) => Response | Promise<Response>,\n        ...routeSchemas,\n        ...(returns ? { returns } : {}),\n      }\n    },\n  }\n\n  return builder as unknown as RouteBuilder<RoutePath, Method, readonly [], ValidatorParts>\n}\n"],"mappings":";;;;;AAiBA,SAAS,WAAW,KAA+D;CACjF,IAAI,CAAC,KACH,OAAO,CAAC;CAEV,MAAM,MAAwC,CAAC;CAC/C,KAAK,MAAM,CAAC,KAAK,WAAW,OAAO,QAAQ,GAAG,GAC5C,IAAI,WAAW,KAAA,GACb,IAAI,OAAO,GAAG,KAAK;CAGvB,OAAO;AACT;AAEA,SAAS,sBAAsB,MAekB;CAO/C,MAAM,UAAU,YAND,iBACb,WAAW,KAAK,iBAAiB,GACjC,WAAW,KAAK,YAAY,GAC5B,WAAW,KAAK,wBAAwB,GACxC,WAAW,KAAK,cAAc,CAEJ,GAAQ,gBAAgB,KAAK,OAAO,CAAC;CACjE,OAAO,OAAO,KAAK,OAAO,CAAC,CAAC,SAAS,IAAI,UAAU,KAAA;AACrD;AAEA,SAAS,eACP,MACA,QACA,SACA,aACA;CACA,OAAO;EACL;EACA;EACA,GAAI,UAAU,EAAE,SAAS,CAAC,GAAG,OAAO,EAAE,IAAI,CAAC;EAC3C,aAAa,CAAC,GAAG,WAAW;CAC9B;AACF;;AAGA,SAAgB,mBACd,MACA,QACA,aAA+B,CAAC,GAChC,SAC8D;CAC9D,MAAM,cAAsC,CAAC;CAC7C,IAAI,eAAiD,CAAC;CAEtD,MAAM,UAAU;EACd;EACA;EACA,QAAQ,KAAiB;GACvB,eAAe;IAAE,GAAG;IAAc,GAAG,WAAW,GAAG;GAAE;GACrD,OAAO;EACT;EACA,IAAI,YAAkC;GACpC,YAAY,KAAK,UAAU;GAC3B,OAAO;EACT;EACA,QAAQ,UAAiD;GACvD,MAAM,eAAe,mBAAmB,UAAU;GAClD,MAAM,OAAO,eAAe,MAAM,QAAQ,SAAS,WAAW;GAE9D,IAAI,cAAc,QAAQ,GAAG;IAC3B,MAAM,iBAAiB,mBAAmB,UAAU,sBAAsB;IAC1E,MAAM,UAAU,sBAAsB;KACpC,mBAAmB,8BAA8B,WAAW;KAC9C;KACd,0BAA0B,8BAA8B,SAAS,WAAW;KAC5E,gBAAgB,SAAS;KACzB,SAAS;MACP,GAAG;MACH,cAAc,SAAS;MACvB,eAAe,SAAS;MACxB,aAAa,SAAS;MACtB;MACA,oBAAoB,SAAS;KAC/B;IACF,CAAC;IAED,OAAO;KACL,GAAG;KACH,oBAAoB,CAAC,GAAG,SAAS,WAAW;KAC5C,SAAS,SAAS;KAClB,GAAG;KACH,GAAG;KACH,GAAI,UAAU,EAAE,QAAQ,IAAI,CAAC;IAC/B;GACF;GAEA,MAAM,UAAU,sBAAsB;IACpC,mBAAmB,8BAA8B,WAAW;IAC9C;IACd,0BAA0B,CAAC;IAC3B,gBAAgB,KAAA;IAChB,SAAS;KACP,GAAG;KACH;IACF;GACF,CAAC;GAED,OAAO;IACL,GAAG;IACH,oBAAoB,CAAC;IACrB,SAAS;IACT,GAAG;IACH,GAAI,UAAU,EAAE,QAAQ,IAAI,CAAC;GAC/B;EACF;CACF;CAEA,OAAO;AACT"}

package/dist/esm/taser-app.d.ts

@@ -0,0 +1,21 @@
+import { TaserRuntime, RouteManifestShape } from '@taserjs/router-core';
+declare class TaserServeView {
+    protected readonly runtime: TaserRuntime;
+    constructor(runtime: TaserRuntime);
+    fetch(request: Request, env?: unknown, executionCtx?: unknown): Promise<Response>;
+    native(native: unknown): TaserNativeBound;
+}
+export declare class TaserNativeBound {
+    private readonly runtime;
+    private readonly boundNative;
+    constructor(runtime: TaserRuntime, boundNative: unknown);
+    fetch(request: Request, env?: unknown, executionCtx?: unknown): Promise<Response>;
+}
+export declare class TaserMountedApp extends TaserServeView {
+}
+export declare class TaserApp<TManifest extends RouteManifestShape = RouteManifestShape> extends TaserServeView {
+    readonly __manifest?: TManifest;
+    constructor(runtime: TaserRuntime, manifest?: TManifest);
+    base(prefix: string): TaserMountedApp;
+}
+export {};

package/dist/esm/taser-app.js

@@ -0,0 +1,40 @@
+//#region src/taser-app.ts
+var TaserServeView = class {
+	runtime;
+	constructor(runtime) {
+		this.runtime = runtime;
+	}
+	fetch(request, env, executionCtx) {
+		return this.runtime.fetch(request, env, executionCtx);
+	}
+	native(native) {
+		return new TaserNativeBound(this.runtime, native);
+	}
+};
+var TaserNativeBound = class {
+	runtime;
+	boundNative;
+	constructor(runtime, boundNative) {
+		this.runtime = runtime;
+		this.boundNative = boundNative;
+	}
+	fetch(request, env, executionCtx) {
+		return this.runtime.native(this.boundNative).fetch(request, env, executionCtx);
+	}
+};
+var TaserMountedApp = class extends TaserServeView {};
+var TaserApp = class extends TaserServeView {
+	__manifest;
+	constructor(runtime, manifest) {
+		super(runtime);
+		if (manifest !== void 0) this.__manifest = manifest;
+	}
+	base(prefix) {
+		this.runtime.registerRoutePrefix(prefix);
+		return new TaserMountedApp(this.runtime);
+	}
+};
+//#endregion
+export { TaserApp, TaserMountedApp, TaserNativeBound };
+
+//# sourceMappingURL=taser-app.js.map

package/dist/esm/taser-app.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"taser-app.js","names":[],"sources":["../../src/taser-app.ts"],"sourcesContent":["import type { TaserRuntime } from '@taserjs/router-core'\nimport type { RouteManifestShape } from '@taserjs/router-core'\n\nclass TaserServeView {\n  constructor(protected readonly runtime: TaserRuntime) { }\n\n  fetch(request: Request, env?: unknown, executionCtx?: unknown): Promise<Response> {\n    return this.runtime.fetch(request, env, executionCtx as never)\n  }\n\n  native(native: unknown): TaserNativeBound {\n    return new TaserNativeBound(this.runtime, native)\n  }\n}\n\nexport class TaserNativeBound {\n  constructor(\n    private readonly runtime: TaserRuntime,\n    private readonly boundNative: unknown,\n  ) { }\n\n  fetch(request: Request, env?: unknown, executionCtx?: unknown): Promise<Response> {\n    return this.runtime.native(this.boundNative).fetch(request, env, executionCtx as never)\n  }\n}\n\nexport class TaserMountedApp extends TaserServeView { }\n\nexport class TaserApp<TManifest extends RouteManifestShape = RouteManifestShape> extends TaserServeView {\n  readonly __manifest?: TManifest\n\n  constructor(runtime: TaserRuntime, manifest?: TManifest) {\n    super(runtime)\n    if (manifest !== undefined) {\n      this.__manifest = manifest\n    }\n  }\n\n  base(prefix: string): TaserMountedApp {\n    this.runtime.registerRoutePrefix(prefix)\n    return new TaserMountedApp(this.runtime)\n  }\n}\n"],"mappings":";AAGA,IAAM,iBAAN,MAAqB;CACY;CAA/B,YAAY,SAA0C;EAAvB,KAAA,UAAA;CAAyB;CAExD,MAAM,SAAkB,KAAe,cAA2C;EAChF,OAAO,KAAK,QAAQ,MAAM,SAAS,KAAK,YAAqB;CAC/D;CAEA,OAAO,QAAmC;EACxC,OAAO,IAAI,iBAAiB,KAAK,SAAS,MAAM;CAClD;AACF;AAEA,IAAa,mBAAb,MAA8B;CAET;CACA;CAFnB,YACE,SACA,aACA;EAFiB,KAAA,UAAA;EACA,KAAA,cAAA;CACf;CAEJ,MAAM,SAAkB,KAAe,cAA2C;EAChF,OAAO,KAAK,QAAQ,OAAO,KAAK,WAAW,CAAC,CAAC,MAAM,SAAS,KAAK,YAAqB;CACxF;AACF;AAEA,IAAa,kBAAb,cAAqC,eAAe,CAAE;AAEtD,IAAa,WAAb,cAAyF,eAAe;CACtG;CAEA,YAAY,SAAuB,UAAsB;EACvD,MAAM,OAAO;EACb,IAAI,aAAa,KAAA,GACf,KAAK,aAAa;CAEtB;CAEA,KAAK,QAAiC;EACpC,KAAK,QAAQ,oBAAoB,MAAM;EACvC,OAAO,IAAI,gBAAgB,KAAK,OAAO;CACzC;AACF"}

package/dist/esm/taser-router.d.ts

@@ -0,0 +1,44 @@
+import { NotFoundHandler, OnErrorHandler, RouteManifestShape } from '@taserjs/router-core';
+import { defineMiddleware } from './define/middleware.js';
+import { TaserApp } from './taser-app.js';
+import { ContextDefinition, CreateTaserAppOptions, OnErrorOptions } from './types/app.js';
+import { AppContext } from './types/units.js';
+import { HandlerBuilder, LayoutId, MiddlewareBuilder } from './types/index.js';
+import { Schema } from './types/schema.js';
+import { CreateAllRoute, CreateAnyRoute, CreateWithBodyRoute, CreateWithoutBodyRoute } from './factories.js';
+type RouterState = {
+    options: CreateTaserAppOptions;
+    contextDef: ContextDefinition<Record<string, unknown>, Record<string, unknown>>;
+    onError?: OnErrorHandler;
+    notFound?: NotFoundHandler;
+};
+export declare class TaserRouter<TAppContext extends Record<string, unknown> = AppContext> {
+    private readonly state;
+    constructor(options?: CreateTaserAppOptions, state?: Partial<Omit<RouterState, 'options'>>);
+    context<TBoot extends Record<string, unknown>, TReq extends Record<string, unknown>>(definition: ContextDefinition<TBoot, TReq>): TaserRouter<TBoot & TReq>;
+    onError<TResponses extends import('./types/returns.js').ReturnsMap = import('./types/returns.js').ReturnsMap>(options: OnErrorOptions<TResponses> | OnErrorOptions<TResponses>['handle']): this;
+    notFound(handler: (ctx: unknown) => Response | Promise<Response> | unknown): this;
+    get: CreateWithoutBodyRoute<'GET', TAppContext>;
+    post: CreateWithBodyRoute<'POST', TAppContext>;
+    put: CreateWithBodyRoute<'PUT', TAppContext>;
+    patch: CreateWithBodyRoute<'PATCH', TAppContext>;
+    delete: CreateWithoutBodyRoute<'DELETE', TAppContext>;
+    options: CreateWithoutBodyRoute<'OPTIONS', TAppContext>;
+    head: CreateWithoutBodyRoute<'HEAD', TAppContext>;
+    any: CreateAnyRoute<TAppContext>;
+    all: CreateAllRoute<TAppContext>;
+    middleware<const Layout extends LayoutId>(layout: Layout): MiddlewareBuilder<Layout, readonly [], TAppContext>;
+    defineHandler<TQuery = unknown, TParams = unknown, TBody = unknown>(options?: {
+        query?: Schema<TQuery>;
+        params?: Schema<TParams>;
+        body?: Schema<TBody>;
+    }): HandlerBuilder<readonly [], {
+        query: TQuery;
+        params: TParams;
+        body: TBody;
+    }, {}, TAppContext>;
+    defineMiddleware(): ReturnType<typeof defineMiddleware<TAppContext>>;
+    create<const TManifest extends RouteManifestShape>(manifest: TManifest): TaserApp<TManifest>;
+}
+export declare function createTaserApp(options?: CreateTaserAppOptions): TaserRouter;
+export {};

package/dist/esm/taser-router.js

@@ -0,0 +1,82 @@
+import { createAllRoute, createAnyRoute, createDeleteRoute, createGetRoute, createHeadRoute, createOptionsRoute, createPatchRoute, createPostRoute, createPutRoute } from "./factories.js";
+import { defineHandler } from "./define/handler.js";
+import { defineMiddleware } from "./define/middleware.js";
+import { createMiddleware } from "./middleware.js";
+import { TaserApp } from "./taser-app.js";
+import { normalizeOnError } from "@taserjs/router-utils";
+import { createTaserRuntime } from "@taserjs/router-core";
+//#region src/taser-router.ts
+function toOnErrorHandler(onErrorOptions) {
+	return normalizeOnError(onErrorOptions);
+}
+var emptyContext = {};
+var TaserRouter = class {
+	state;
+	constructor(options = {}, state) {
+		this.state = {
+			options,
+			contextDef: state?.contextDef ?? emptyContext,
+			...state?.onError !== void 0 ? { onError: state.onError } : {},
+			...state?.notFound !== void 0 ? { notFound: state.notFound } : {}
+		};
+	}
+	context(definition) {
+		this.state.contextDef = definition;
+		return this;
+	}
+	onError(options) {
+		this.state.onError = toOnErrorHandler(options);
+		return this;
+	}
+	notFound(handler) {
+		this.state.notFound = (ctx) => handler(ctx);
+		return this;
+	}
+	get = createGetRoute;
+	post = createPostRoute;
+	put = createPutRoute;
+	patch = createPatchRoute;
+	delete = createDeleteRoute;
+	options = createOptionsRoute;
+	head = createHeadRoute;
+	any = createAnyRoute;
+	all = createAllRoute;
+	middleware(layout) {
+		return createMiddleware(layout);
+	}
+	defineHandler(options) {
+		return options === void 0 ? defineHandler() : defineHandler(options);
+	}
+	defineMiddleware() {
+		return defineMiddleware();
+	}
+	create(manifest) {
+		const definition = this.state.contextDef;
+		const validateResponse = this.state.options.response?.validate ?? true;
+		const onValidationFailure = this.state.options.response?.onValidationFailure;
+		const bootPromise = Promise.resolve(definition.boot?.() ?? {});
+		return new TaserApp(createTaserRuntime(manifest, async ({ native }) => {
+			const bootContext = await bootPromise;
+			const requestContext = await definition.request?.({ native }) ?? {};
+			return {
+				...bootContext,
+				...requestContext
+			};
+		}, {
+			response: {
+				validate: validateResponse,
+				...onValidationFailure !== void 0 ? { onValidationFailure } : {}
+			},
+			...this.state.onError !== void 0 ? { onError: this.state.onError } : {},
+			...this.state.notFound !== void 0 ? { notFound: this.state.notFound } : {},
+			...this.state.options.cookies !== void 0 ? { cookies: this.state.options.cookies } : {}
+		}), manifest);
+	}
+};
+function createTaserApp(options = {}) {
+	return new TaserRouter(options);
+}
+//#endregion
+export { TaserRouter, createTaserApp };
+
+//# sourceMappingURL=taser-router.js.map

package/dist/esm/taser-router.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"taser-router.js","names":[],"sources":["../../src/taser-router.ts"],"sourcesContent":["import {\n  createTaserRuntime,\n  type NotFoundHandler,\n  type OnErrorHandler,\n  type RouteManifestShape,\n} from '@taserjs/router-core'\nimport { normalizeOnError } from '@taserjs/router-utils'\n\nimport {\n  createAllRoute,\n  createAnyRoute,\n  createDeleteRoute,\n  createGetRoute,\n  createHeadRoute,\n  createOptionsRoute,\n  createPatchRoute,\n  createPostRoute,\n  createPutRoute,\n} from './factories.js'\nimport { defineHandler } from './define/handler.js'\nimport { defineMiddleware } from './define/middleware.js'\nimport { createMiddleware } from './middleware.js'\nimport { TaserApp } from './taser-app.js'\nimport type {\n  ContextDefinition,\n  CreateTaserAppOptions,\n  OnErrorOptions,\n} from './types/app.js'\nimport type { AppContext } from './types/units.js'\nimport type { HandlerBuilder, LayoutId, MiddlewareBuilder } from './types/index.js'\nimport type { Schema } from './types/schema.js'\nimport type {\n  CreateAllRoute,\n  CreateAnyRoute,\n  CreateWithBodyRoute,\n  CreateWithoutBodyRoute,\n} from './factories.js'\n\nfunction toOnErrorHandler(\n  onErrorOptions: OnErrorOptions | OnErrorOptions['handle'],\n): OnErrorHandler {\n  return normalizeOnError(onErrorOptions)\n}\n\ntype RouterState = {\n  options: CreateTaserAppOptions\n  contextDef: ContextDefinition<Record<string, unknown>, Record<string, unknown>>\n  onError?: OnErrorHandler\n  notFound?: NotFoundHandler\n}\n\nconst emptyContext: ContextDefinition<Record<string, unknown>, Record<string, unknown>> = {}\n\nexport class TaserRouter<TAppContext extends Record<string, unknown> = AppContext> {\n  private readonly state: RouterState\n\n  constructor(options: CreateTaserAppOptions = {}, state?: Partial<Omit<RouterState, 'options'>>) {\n    this.state = {\n      options,\n      contextDef: state?.contextDef ?? emptyContext,\n      ...(state?.onError !== undefined ? { onError: state.onError } : {}),\n      ...(state?.notFound !== undefined ? { notFound: state.notFound } : {}),\n    }\n  }\n\n  context<\n    TBoot extends Record<string, unknown>,\n    TReq extends Record<string, unknown>,\n  >(definition: ContextDefinition<TBoot, TReq>): TaserRouter<TBoot & TReq> {\n    this.state.contextDef = definition\n    return this as unknown as TaserRouter<TBoot & TReq>\n  }\n\n  onError<TResponses extends import('./types/returns.js').ReturnsMap = import('./types/returns.js').ReturnsMap>(\n    options: OnErrorOptions<TResponses> | OnErrorOptions<TResponses>['handle'],\n  ): this {\n    this.state.onError = toOnErrorHandler(options)\n    return this\n  }\n\n  notFound(\n    handler: (ctx: unknown) => Response | Promise<Response> | unknown,\n  ): this {\n    this.state.notFound = ctx => handler(ctx)\n    return this\n  }\n\n  get: CreateWithoutBodyRoute<'GET', TAppContext> = createGetRoute as CreateWithoutBodyRoute<'GET', TAppContext>\n  post: CreateWithBodyRoute<'POST', TAppContext> = createPostRoute as CreateWithBodyRoute<'POST', TAppContext>\n  put: CreateWithBodyRoute<'PUT', TAppContext> = createPutRoute as CreateWithBodyRoute<'PUT', TAppContext>\n  patch: CreateWithBodyRoute<'PATCH', TAppContext> = createPatchRoute as CreateWithBodyRoute<'PATCH', TAppContext>\n  delete: CreateWithoutBodyRoute<'DELETE', TAppContext> = createDeleteRoute as CreateWithoutBodyRoute<'DELETE', TAppContext>\n  options: CreateWithoutBodyRoute<'OPTIONS', TAppContext> = createOptionsRoute as CreateWithoutBodyRoute<'OPTIONS', TAppContext>\n  head: CreateWithoutBodyRoute<'HEAD', TAppContext> = createHeadRoute as CreateWithoutBodyRoute<'HEAD', TAppContext>\n  any: CreateAnyRoute<TAppContext> = createAnyRoute as CreateAnyRoute<TAppContext>\n  all: CreateAllRoute<TAppContext> = createAllRoute as CreateAllRoute<TAppContext>\n\n  middleware<const Layout extends LayoutId>(layout: Layout): MiddlewareBuilder<Layout, readonly [], TAppContext> {\n    return createMiddleware(layout) as MiddlewareBuilder<Layout, readonly [], TAppContext>\n  }\n\n  defineHandler<\n    TQuery = unknown,\n    TParams = unknown,\n    TBody = unknown,\n  >(\n    options?: {\n      query?: Schema<TQuery>\n      params?: Schema<TParams>\n      body?: Schema<TBody>\n    },\n  ): HandlerBuilder<\n    readonly [],\n    { query: TQuery, params: TParams, body: TBody },\n    {},\n    TAppContext\n  > {\n    return options === undefined\n      ? defineHandler<TAppContext>()\n      : defineHandler<TAppContext>(options)\n  }\n\n  defineMiddleware(): ReturnType<typeof defineMiddleware<TAppContext>> {\n    return defineMiddleware<TAppContext>()\n  }\n\n  create<const TManifest extends RouteManifestShape>(manifest: TManifest): TaserApp<TManifest> {\n    const definition = this.state.contextDef\n    const validateResponse = this.state.options.response?.validate ?? true\n    const onValidationFailure = this.state.options.response?.onValidationFailure\n    const bootPromise = Promise.resolve(\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n      definition.boot?.() ?? ({} as Record<string, unknown>),\n    )\n\n    const runtime = createTaserRuntime(\n      manifest,\n      async ({ native }) => {\n        const bootContext = await bootPromise\n        const requestContext = await definition.request?.({ native }) ?? {}\n        return { ...bootContext, ...requestContext }\n      },\n      {\n        response: {\n          validate: validateResponse,\n          ...(onValidationFailure !== undefined ? { onValidationFailure } : {}),\n        },\n        ...(this.state.onError !== undefined ? { onError: this.state.onError } : {}),\n        ...(this.state.notFound !== undefined ? { notFound: this.state.notFound } : {}),\n        ...(this.state.options.cookies !== undefined ? { cookies: this.state.options.cookies } : {}),\n      },\n    )\n\n    return new TaserApp(runtime, manifest)\n  }\n}\n\nexport function createTaserApp(options: CreateTaserAppOptions = {}): TaserRouter {\n  return new TaserRouter(options)\n}\n"],"mappings":";;;;;;;;AAsCA,SAAS,iBACP,gBACgB;CAChB,OAAO,iBAAiB,cAAc;AACxC;AASA,IAAM,eAAoF,CAAC;AAE3F,IAAa,cAAb,MAAmF;CACjF;CAEA,YAAY,UAAiC,CAAC,GAAG,OAA+C;EAC9F,KAAK,QAAQ;GACX;GACA,YAAY,OAAO,cAAc;GACjC,GAAI,OAAO,YAAY,KAAA,IAAY,EAAE,SAAS,MAAM,QAAQ,IAAI,CAAC;GACjE,GAAI,OAAO,aAAa,KAAA,IAAY,EAAE,UAAU,MAAM,SAAS,IAAI,CAAC;EACtE;CACF;CAEA,QAGE,YAAuE;EACvE,KAAK,MAAM,aAAa;EACxB,OAAO;CACT;CAEA,QACE,SACM;EACN,KAAK,MAAM,UAAU,iBAAiB,OAAO;EAC7C,OAAO;CACT;CAEA,SACE,SACM;EACN,KAAK,MAAM,YAAW,QAAO,QAAQ,GAAG;EACxC,OAAO;CACT;CAEA,MAAkD;CAClD,OAAiD;CACjD,MAA+C;CAC/C,QAAmD;CACnD,SAAwD;CACxD,UAA0D;CAC1D,OAAoD;CACpD,MAAmC;CACnC,MAAmC;CAEnC,WAA0C,QAAqE;EAC7G,OAAO,iBAAiB,MAAM;CAChC;CAEA,cAKE,SAUA;EACA,OAAO,YAAY,KAAA,IACf,cAA2B,IAC3B,cAA2B,OAAO;CACxC;CAEA,mBAAqE;EACnE,OAAO,iBAA8B;CACvC;CAEA,OAAmD,UAA0C;EAC3F,MAAM,aAAa,KAAK,MAAM;EAC9B,MAAM,mBAAmB,KAAK,MAAM,QAAQ,UAAU,YAAY;EAClE,MAAM,sBAAsB,KAAK,MAAM,QAAQ,UAAU;EACzD,MAAM,cAAc,QAAQ,QAE1B,WAAW,OAAO,KAAM,CAAC,CAC3B;EAoBA,OAAO,IAAI,SAlBK,mBACd,UACA,OAAO,EAAE,aAAa;GACpB,MAAM,cAAc,MAAM;GAC1B,MAAM,iBAAiB,MAAM,WAAW,UAAU,EAAE,OAAO,CAAC,KAAK,CAAC;GAClE,OAAO;IAAE,GAAG;IAAa,GAAG;GAAe;EAC7C,GACA;GACE,UAAU;IACR,UAAU;IACV,GAAI,wBAAwB,KAAA,IAAY,EAAE,oBAAoB,IAAI,CAAC;GACrE;GACA,GAAI,KAAK,MAAM,YAAY,KAAA,IAAY,EAAE,SAAS,KAAK,MAAM,QAAQ,IAAI,CAAC;GAC1E,GAAI,KAAK,MAAM,aAAa,KAAA,IAAY,EAAE,UAAU,KAAK,MAAM,SAAS,IAAI,CAAC;GAC7E,GAAI,KAAK,MAAM,QAAQ,YAAY,KAAA,IAAY,EAAE,SAAS,KAAK,MAAM,QAAQ,QAAQ,IAAI,CAAC;EAC5F,CAGkB,GAAS,QAAQ;CACvC;AACF;AAEA,SAAgB,eAAe,UAAiC,CAAC,GAAgB;CAC/E,OAAO,IAAI,YAAY,OAAO;AAChC"}

package/dist/esm/types/app.d.ts

@@ -0,0 +1,46 @@
+import { ResponseValidationFailureHandler } from '@taserjs/router-utils';
+import { TaserApp } from '../taser-app.js';
+import { ReturnsMap } from './returns.js';
+import { Schema } from './schema.js';
+export type CreateTaserAppOptions = {
+    response?: {
+        /** Validate handler replies against returns maps. Default true. */
+        validate?: boolean;
+        onValidationFailure?: ResponseValidationFailureHandler;
+    };
+    /** Global cookie defaults and signing secret. Per-call `ctx.cookies.set` options override defaults. */
+    cookies?: {
+        secret?: string | BufferSource;
+        path?: string;
+        httpOnly?: boolean;
+        sameSite?: 'Strict' | 'Lax' | 'None' | 'strict' | 'lax' | 'none';
+        secure?: boolean;
+        domain?: string;
+        maxAge?: number;
+        expires?: Date;
+    };
+};
+export type CreateContextArgs = {
+    native?: import('./units.js').NativeContext;
+};
+export type ContextDefinition<TBoot extends Record<string, unknown> = Record<string, never>, TReq extends Record<string, unknown> = Record<string, never>> = {
+    boot?: () => TBoot | Promise<TBoot>;
+    request?: (args: CreateContextArgs) => TReq | Promise<TReq>;
+};
+export type InferAppContext<T extends ContextDefinition<Record<string, unknown>, Record<string, unknown>>> = T extends ContextDefinition<infer TBoot, infer TReq> ? TBoot & TReq : Record<string, never>;
+export type OnErrorOptions<TResponses extends ReturnsMap = ReturnsMap> = {
+    responses?: TResponses;
+    handle: (error: unknown, ctx?: unknown) => Response | Promise<Response>;
+};
+export type InferAppManifest<TApp> = TApp extends TaserApp<infer TManifest> ? TManifest : never;
+export type TaserHandler<TFrameworkApp> = {
+    /**
+     * Mount the Taser handler on a framework app.
+     * Use universal wildcard patterns (`/*`, `/prefix/*`) for Hono/Fastify.
+     * Use framework-native splat patterns for Express (e.g. `/{*splat}`, `/*splat`).
+     */
+    mount(pattern: string, frameworkApp: TFrameworkApp): void;
+};
+export type { RouteManifestShape } from '@taserjs/router-core';
+export type { Schema };
+export type { TaserApp, TaserMountedApp, TaserNativeBound } from '../taser-app.js';