@taserjs/router 0.0.0

package/dist/cjs/middleware/cors.d.cts

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

package/dist/cjs/middleware/csrf.cjs

@@ -0,0 +1,12 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_auth = require("./auth.cjs");
+let hono_csrf = require("hono/csrf");
+//#region src/middleware/csrf.ts
+var honoCsrfMiddleware = require_auth.wrapHonoMiddleware(hono_csrf.csrf);
+function csrf(...args) {
+	return honoCsrfMiddleware(...args);
+}
+//#endregion
+exports.csrf = csrf;
+
+//# sourceMappingURL=csrf.cjs.map

package/dist/cjs/middleware/csrf.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"csrf.cjs","names":[],"sources":["../../../src/middleware/csrf.ts"],"sourcesContent":["import { csrf as honoCsrf } from 'hono/csrf'\n\nimport { wrapHonoMiddleware } from './auth.js'\n\nconst honoCsrfMiddleware = wrapHonoMiddleware(honoCsrf)\n\nexport function csrf(...args: Parameters<typeof honoCsrf>) {\n  return honoCsrfMiddleware(...args)\n}\n\nexport type CsrfOptions = NonNullable<Parameters<typeof honoCsrf>[0]>\n"],"mappings":";;;;AAIA,IAAM,qBAAqB,aAAA,mBAAmB,UAAA,IAAQ;AAEtD,SAAgB,KAAK,GAAG,MAAmC;CACzD,OAAO,mBAAmB,GAAG,IAAI;AACnC"}

package/dist/cjs/middleware/csrf.d.cts

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

package/dist/cjs/middleware/etag.cjs

@@ -0,0 +1,12 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_auth = require("./auth.cjs");
+let hono_etag = require("hono/etag");
+//#region src/middleware/etag.ts
+var honoEtagMiddleware = require_auth.wrapHonoMiddleware(hono_etag.etag);
+function etag(...args) {
+	return honoEtagMiddleware(...args);
+}
+//#endregion
+exports.etag = etag;
+
+//# sourceMappingURL=etag.cjs.map

package/dist/cjs/middleware/etag.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"etag.cjs","names":[],"sources":["../../../src/middleware/etag.ts"],"sourcesContent":["import { etag as honoEtag } from 'hono/etag'\n\nimport { wrapHonoMiddleware } from './auth.js'\n\nconst honoEtagMiddleware = wrapHonoMiddleware(honoEtag)\n\nexport function etag(...args: Parameters<typeof honoEtag>) {\n  return honoEtagMiddleware(...args)\n}\n\nexport type EtagOptions = NonNullable<Parameters<typeof honoEtag>[0]>\n"],"mappings":";;;;AAIA,IAAM,qBAAqB,aAAA,mBAAmB,UAAA,IAAQ;AAEtD,SAAgB,KAAK,GAAG,MAAmC;CACzD,OAAO,mBAAmB,GAAG,IAAI;AACnC"}

package/dist/cjs/middleware/etag.d.cts

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

package/dist/cjs/middleware/jwk.cjs

@@ -0,0 +1,25 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_auth = require("./auth.cjs");
+let hono_jwk = require("hono/jwk");
+//#region src/middleware/jwk.ts
+function assertJwksScheme(jwksUri, allowInsecure) {
+	const scheme = new URL(jwksUri).protocol.replace(":", "");
+	if (scheme === "https") return;
+	if (scheme === "http" && allowInsecure) return;
+	throw new Error(`JWKS URL must use https:// (or http:// with allowInsecure: true): "${jwksUri}"`);
+}
+/**
+* JWK auth middleware. Invalid or missing tokens return **401** (Hono).
+* Valid tokens whose payload fails `payloadSchema` return **403**.
+* Static `jwks_uri` must use HTTPS unless `allowInsecure: true`.
+*/
+function jwk(payloadSchema, options, init) {
+	const jwksUri = options.jwks_uri;
+	if (typeof jwksUri === "string") assertJwksScheme(jwksUri, options.allowInsecure ?? false);
+	const { allowInsecure: _allowInsecure, ...honoOptions } = options;
+	return require_auth.createAuthMiddleware(payloadSchema, (0, hono_jwk.jwk)(honoOptions, init?.headers !== void 0 ? { headers: init.headers } : void 0));
+}
+//#endregion
+exports.jwk = jwk;
+
+//# sourceMappingURL=jwk.cjs.map

package/dist/cjs/middleware/jwk.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"jwk.cjs","names":[],"sources":["../../../src/middleware/jwk.ts"],"sourcesContent":["import { jwk as honoJwk } from 'hono/jwk'\n\nimport { createAuthMiddleware, type AuthMiddlewareUnit } from './auth.js'\nimport type { InferOutput, Schema } from '../types/schema.js'\n\nexport type JwkOptions = Parameters<typeof honoJwk>[0]\n\nexport type JwkRequestInit = Pick<RequestInit, 'headers'>\n\nexport type JwkMiddlewareOptions = JwkOptions & {\n  /** Allow `http://` JWKS URLs (local dev). Default false — requires `https://`. */\n  allowInsecure?: boolean\n}\n\nfunction assertJwksScheme(jwksUri: string, allowInsecure: boolean): void {\n  const scheme = new URL(jwksUri).protocol.replace(':', '')\n  if (scheme === 'https') {\n    return\n  }\n  if (scheme === 'http' && allowInsecure) {\n    return\n  }\n  throw new Error(\n    `JWKS URL must use https:// (or http:// with allowInsecure: true): \"${jwksUri}\"`,\n  )\n}\n\n/**\n * JWK auth middleware. Invalid or missing tokens return **401** (Hono).\n * Valid tokens whose payload fails `payloadSchema` return **403**.\n * Static `jwks_uri` must use HTTPS unless `allowInsecure: true`.\n */\nexport function jwk<TPayload>(\n  payloadSchema: Schema<TPayload>,\n  options: JwkMiddlewareOptions,\n  init?: JwkRequestInit,\n): AuthMiddlewareUnit<InferOutput<Schema<TPayload>>> {\n  const jwksUri = options.jwks_uri\n  if (typeof jwksUri === 'string') {\n    assertJwksScheme(jwksUri, options.allowInsecure ?? false)\n  }\n\n  const { allowInsecure: _allowInsecure, ...honoOptions } = options\n  const safeInit = init?.headers !== undefined ? { headers: init.headers } : undefined\n\n  return createAuthMiddleware(payloadSchema, honoJwk(honoOptions, safeInit))\n}\n"],"mappings":";;;;AAcA,SAAS,iBAAiB,SAAiB,eAA8B;CACvE,MAAM,SAAS,IAAI,IAAI,OAAO,CAAC,CAAC,SAAS,QAAQ,KAAK,EAAE;CACxD,IAAI,WAAW,SACb;CAEF,IAAI,WAAW,UAAU,eACvB;CAEF,MAAM,IAAI,MACR,sEAAsE,QAAQ,EAChF;AACF;;;;;;AAOA,SAAgB,IACd,eACA,SACA,MACmD;CACnD,MAAM,UAAU,QAAQ;CACxB,IAAI,OAAO,YAAY,UACrB,iBAAiB,SAAS,QAAQ,iBAAiB,KAAK;CAG1D,MAAM,EAAE,eAAe,gBAAgB,GAAG,gBAAgB;CAG1D,OAAO,aAAA,qBAAqB,gBAAA,GAAA,SAAA,IAAA,CAAuB,aAFlC,MAAM,YAAY,KAAA,IAAY,EAAE,SAAS,KAAK,QAAQ,IAAI,KAAA,CAEH,CAAC;AAC3E"}

package/dist/cjs/middleware/jwk.d.cts

@@ -0,0 +1,15 @@
+import { jwk as honoJwk } from 'hono/jwk';
+import { AuthMiddlewareUnit } from './auth.js';
+import { InferOutput, Schema } from '../types/schema.js';
+export type JwkOptions = Parameters<typeof honoJwk>[0];
+export type JwkRequestInit = Pick<RequestInit, 'headers'>;
+export type JwkMiddlewareOptions = JwkOptions & {
+    /** Allow `http://` JWKS URLs (local dev). Default false — requires `https://`. */
+    allowInsecure?: boolean;
+};
+/**
+ * JWK auth middleware. Invalid or missing tokens return **401** (Hono).
+ * Valid tokens whose payload fails `payloadSchema` return **403**.
+ * Static `jwks_uri` must use HTTPS unless `allowInsecure: true`.
+ */
+export declare function jwk<TPayload>(payloadSchema: Schema<TPayload>, options: JwkMiddlewareOptions, init?: JwkRequestInit): AuthMiddlewareUnit<InferOutput<Schema<TPayload>>>;

package/dist/cjs/middleware/jwt.cjs

@@ -0,0 +1,16 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_auth = require("./auth.cjs");
+let hono_jwt = require("hono/jwt");
+//#region src/middleware/jwt.ts
+/**
+* JWT auth middleware. Invalid or missing tokens return **401** (Hono).
+* Valid tokens whose payload fails `payloadSchema` return **403**.
+* Use optional schema fields for intentionally optional claims.
+*/
+function jwt(payloadSchema, options) {
+	return require_auth.createAuthMiddleware(payloadSchema, (0, hono_jwt.jwt)(options));
+}
+//#endregion
+exports.jwt = jwt;
+
+//# sourceMappingURL=jwt.cjs.map

package/dist/cjs/middleware/jwt.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"jwt.cjs","names":[],"sources":["../../../src/middleware/jwt.ts"],"sourcesContent":["import { jwt as honoJwt } from 'hono/jwt'\n\nimport { createAuthMiddleware, type AuthMiddlewareUnit } from './auth.js'\nimport type { InferOutput, Schema } from '../types/schema.js'\n\nexport type JwtOptions = Parameters<typeof honoJwt>[0]\n\n/**\n * JWT auth middleware. Invalid or missing tokens return **401** (Hono).\n * Valid tokens whose payload fails `payloadSchema` return **403**.\n * Use optional schema fields for intentionally optional claims.\n */\nexport function jwt<TPayload>(\n  payloadSchema: Schema<TPayload>,\n  options: JwtOptions,\n): AuthMiddlewareUnit<InferOutput<Schema<TPayload>>> {\n  return createAuthMiddleware(payloadSchema, honoJwt(options))\n}\n"],"mappings":";;;;;;;;;AAYA,SAAgB,IACd,eACA,SACmD;CACnD,OAAO,aAAA,qBAAqB,gBAAA,GAAA,SAAA,IAAA,CAAuB,OAAO,CAAC;AAC7D"}

package/dist/cjs/middleware/jwt.d.cts

@@ -0,0 +1,10 @@
+import { jwt as honoJwt } from 'hono/jwt';
+import { AuthMiddlewareUnit } from './auth.js';
+import { InferOutput, Schema } from '../types/schema.js';
+export type JwtOptions = Parameters<typeof honoJwt>[0];
+/**
+ * JWT auth middleware. Invalid or missing tokens return **401** (Hono).
+ * Valid tokens whose payload fails `payloadSchema` return **403**.
+ * Use optional schema fields for intentionally optional claims.
+ */
+export declare function jwt<TPayload>(payloadSchema: Schema<TPayload>, options: JwtOptions): AuthMiddlewareUnit<InferOutput<Schema<TPayload>>>;

package/dist/cjs/middleware/secure-headers.cjs

@@ -0,0 +1,12 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_auth = require("./auth.cjs");
+let hono_secure_headers = require("hono/secure-headers");
+//#region src/middleware/secure-headers.ts
+var honoSecureHeadersMiddleware = require_auth.wrapHonoMiddleware(hono_secure_headers.secureHeaders);
+function secureHeaders(...args) {
+	return honoSecureHeadersMiddleware(...args);
+}
+//#endregion
+exports.secureHeaders = secureHeaders;
+
+//# sourceMappingURL=secure-headers.cjs.map

package/dist/cjs/middleware/secure-headers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"secure-headers.cjs","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,aAAA,mBAAmB,oBAAA,aAAiB;AAExE,SAAgB,cAAc,GAAG,MAA4C;CAC3E,OAAO,4BAA4B,GAAG,IAAI;AAC5C"}

package/dist/cjs/middleware/secure-headers.d.cts

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

package/dist/cjs/middleware/timing.cjs

@@ -0,0 +1,12 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_auth = require("./auth.cjs");
+let hono_timing = require("hono/timing");
+//#region src/middleware/timing.ts
+var honoTimingMiddleware = require_auth.wrapHonoMiddleware(hono_timing.timing);
+function timing(...args) {
+	return honoTimingMiddleware(...args);
+}
+//#endregion
+exports.timing = timing;
+
+//# sourceMappingURL=timing.cjs.map

package/dist/cjs/middleware/timing.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"timing.cjs","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,aAAA,mBAAmB,YAAA,MAAU;AAE1D,SAAgB,OAAO,GAAG,MAAqC;CAC7D,OAAO,qBAAqB,GAAG,IAAI;AACrC"}

package/dist/cjs/middleware/timing.d.cts

@@ -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/cjs/middleware.cjs

@@ -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
+exports.createMiddleware = createMiddleware;
+
+//# sourceMappingURL=middleware.cjs.map

package/dist/cjs/middleware.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.cjs","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/cjs/middleware.d.cts

@@ -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/cjs/register.d.cts

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

package/dist/cjs/route.cjs

@@ -0,0 +1,94 @@
+const require_units = require("./types/units.cjs");
+const require_constants = require("./constants.cjs");
+const require_validators = require("./define/validators.cjs");
+let _taserjs_router_utils = require("@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 = (0, _taserjs_router_utils.withAuto422)((0, _taserjs_router_utils.mergeReturnsMaps)(toUtilsMap(args.middlewareReturns), toUtilsMap(args.routeReturns), toUtilsMap(args.handlerMiddlewareReturns), toUtilsMap(args.handlerReturns)), (0, _taserjs_router_utils.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 = require_validators.pickDefinedSchemas(validators);
+			const base = buildRouteBase(path, method, methods, middlewares);
+			if (require_units.isHandlerUnit(fnOrUnit)) {
+				const handlerSchemas = require_validators.pickDefinedSchemas(fnOrUnit, require_constants.HANDLER_SCHEMA_KEY_MAP);
+				const returns = buildEffectiveReturns({
+					middlewareReturns: (0, _taserjs_router_utils.collectReturnsFromDefinitions)(middlewares),
+					routeReturns,
+					handlerMiddlewareReturns: (0, _taserjs_router_utils.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: (0, _taserjs_router_utils.collectReturnsFromDefinitions)(middlewares),
+				routeReturns,
+				handlerMiddlewareReturns: {},
+				handlerReturns: void 0,
+				schemas: {
+					...validators,
+					middlewares
+				}
+			});
+			return {
+				...base,
+				handlerMiddlewares: [],
+				handler: fnOrUnit,
+				...routeSchemas,
+				...returns ? { returns } : {}
+			};
+		}
+	};
+	return builder;
+}
+//#endregion
+exports.createRouteBuilder = createRouteBuilder;
+
+//# sourceMappingURL=route.cjs.map

package/dist/cjs/route.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.cjs","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,WAAA,GAAA,sBAAA,YAAA,EAAA,GAAA,sBAAA,iBAAA,CALJ,WAAW,KAAK,iBAAiB,GACjC,WAAW,KAAK,YAAY,GAC5B,WAAW,KAAK,wBAAwB,GACxC,WAAW,KAAK,cAAc,CAEJ,IAAA,GAAA,sBAAA,gBAAA,CAAwB,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,mBAAA,mBAAmB,UAAU;GAClD,MAAM,OAAO,eAAe,MAAM,QAAQ,SAAS,WAAW;GAE9D,IAAI,cAAA,cAAc,QAAQ,GAAG;IAC3B,MAAM,iBAAiB,mBAAA,mBAAmB,UAAU,kBAAA,sBAAsB;IAC1E,MAAM,UAAU,sBAAsB;KACpC,oBAAA,GAAA,sBAAA,8BAAA,CAAiD,WAAW;KAC9C;KACd,2BAAA,GAAA,sBAAA,8BAAA,CAAwD,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,oBAAA,GAAA,sBAAA,8BAAA,CAAiD,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/cjs/route.d.cts

@@ -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/cjs/taser-app.cjs

@@ -0,0 +1,42 @@
+//#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
+exports.TaserApp = TaserApp;
+exports.TaserMountedApp = TaserMountedApp;
+exports.TaserNativeBound = TaserNativeBound;
+
+//# sourceMappingURL=taser-app.cjs.map

package/dist/cjs/taser-app.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"taser-app.cjs","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/cjs/taser-app.d.cts

@@ -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/cjs/taser-router.cjs

@@ -0,0 +1,83 @@
+const require_factories = require("./factories.cjs");
+const require_handler = require("./define/handler.cjs");
+const require_middleware = require("./define/middleware.cjs");
+const require_middleware$1 = require("./middleware.cjs");
+const require_taser_app = require("./taser-app.cjs");
+let _taserjs_router_utils = require("@taserjs/router-utils");
+let _taserjs_router_core = require("@taserjs/router-core");
+//#region src/taser-router.ts
+function toOnErrorHandler(onErrorOptions) {
+	return (0, _taserjs_router_utils.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 = require_factories.createGetRoute;
+	post = require_factories.createPostRoute;
+	put = require_factories.createPutRoute;
+	patch = require_factories.createPatchRoute;
+	delete = require_factories.createDeleteRoute;
+	options = require_factories.createOptionsRoute;
+	head = require_factories.createHeadRoute;
+	any = require_factories.createAnyRoute;
+	all = require_factories.createAllRoute;
+	middleware(layout) {
+		return require_middleware$1.createMiddleware(layout);
+	}
+	defineHandler(options) {
+		return options === void 0 ? require_handler.defineHandler() : require_handler.defineHandler(options);
+	}
+	defineMiddleware() {
+		return require_middleware.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 require_taser_app.TaserApp((0, _taserjs_router_core.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
+exports.TaserRouter = TaserRouter;
+exports.createTaserApp = createTaserApp;
+
+//# sourceMappingURL=taser-router.cjs.map

package/dist/cjs/taser-router.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"taser-router.cjs","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,QAAA,GAAA,sBAAA,iBAAA,CAAwB,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,kBAAA;CAClD,OAAiD,kBAAA;CACjD,MAA+C,kBAAA;CAC/C,QAAmD,kBAAA;CACnD,SAAwD,kBAAA;CACxD,UAA0D,kBAAA;CAC1D,OAAoD,kBAAA;CACpD,MAAmC,kBAAA;CACnC,MAAmC,kBAAA;CAEnC,WAA0C,QAAqE;EAC7G,OAAO,qBAAA,iBAAiB,MAAM;CAChC;CAEA,cAKE,SAUA;EACA,OAAO,YAAY,KAAA,IACf,gBAAA,cAA2B,IAC3B,gBAAA,cAA2B,OAAO;CACxC;CAEA,mBAAqE;EACnE,OAAO,mBAAA,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,kBAAA,UAAA,GAAA,qBAAA,mBAAA,CAjBT,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/cjs/taser-router.d.cts

@@ -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/cjs/types/app.d.cts

@@ -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';