@taserjs/router 0.1.13 → 0.2.1

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

@@ -1,34 +0,0 @@
-import { ReplyOf } from '@taserjs/router-utils/reply';
-import { StatusCode } from '@taserjs/router-utils';
-import { Simplify } from './type-utils.js';
-import { Schema, InferOutput } from './schema.js';
-export type { StatusCode };
-/** Status-code → Standard Schema map for route/middleware/handler outputs. */
-export type ReturnsMap = {
-    readonly [status: number]: Schema<unknown> | undefined;
-};
-/** Later map wins on overlapping status keys. */
-export type MergeReturns<A extends ReturnsMap, B extends ReturnsMap> = Omit<A, keyof B> & B;
-/** Typed reply union for statuses declared in a returns map. */
-export type ReplyFor<M extends ReturnsMap> = {
-    [S in keyof M & number]: M[S] extends Schema<unknown> ? ReplyOf<S, Simplify<InferOutput<M[S]>>> : never;
-}[keyof M & number];
-export type EmptyReturns = {};
-/** True when no status schemas have been declared yet. */
-export type HasReturns<M extends ReturnsMap> = [keyof M] extends [never] ? false : true;
-/**
- * Validate a concrete reply `R` against returns map `M`.
- * Declared statuses must match schema output; undeclared statuses stay open
- * (same rule as runtime `validateReply`).
- */
-export type ValidHandlerReply<R, M extends ReturnsMap> = R extends ReplyOf<infer S, infer B> ? S extends keyof M ? M[S] extends Schema<unknown> ? B extends Simplify<InferOutput<M[S]>> ? R : never : R : R : R extends Response ? R : never;
-/**
- * Narrow a handler return so declared statuses are schema-checked without
- * breaking multi-status unions (avoids circular `R extends …<R>` constraints).
- */
-export type EnforceHandlerReply<R, M extends ReturnsMap> = [R] extends [ValidHandlerReply<R, M>] ? R : ValidHandlerReply<R, M>;
-/**
- * Expected `.handler` return type for a returns map.
- * Prefer constraining handler generics with {@link EnforceHandlerReply}.
- */
-export type HandlerReply<M extends ReturnsMap> = HasReturns<M> extends true ? ReplyFor<M> | Response : Response;

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

@@ -1,14 +0,0 @@
-import { StandardSchemaV1 } from '@standard-schema/spec';
-import { RequestShape } from './type-utils.js';
-export type { StandardSchemaV1 } from '@standard-schema/spec';
-/**
- * A Standard Schema validator.
- * `TOutput` is the validated/output type; `TInput` is the pre-parse input (request shape).
- */
-export type Schema<TOutput = unknown, TInput = unknown> = StandardSchemaV1<TInput, TOutput>;
-/** Infers the output type from a Standard Schema. */
-export type InferOutput<S> = S extends StandardSchemaV1<unknown, infer O> ? O : never;
-/** Infers the input type from a Standard Schema. */
-export type InferInput<S> = S extends StandardSchemaV1<infer I, unknown> ? I : never;
-/** Pre-parse request shape from a Standard Schema. */
-export type SchemaRequestShape<S> = S extends StandardSchemaV1<infer I, infer O> ? RequestShape<I, O> : S;

package/dist/esm/types/type-utils.d.ts

@@ -1,50 +0,0 @@
-import { TaserCookieJar, TaserHeaders } from '@taserjs/router-core';
-import { HttpMethod, HttpVerb } from '@taserjs/router-utils/http';
-export type Method = HttpMethod;
-export type { HttpMethod, HttpVerb };
-export type MiddlewareFieldName = "query" | "params" | "body" | "state";
-export type MiddlewareInputFieldName = "query" | "params" | "body";
-export type UnwrapPart<T> = unknown extends T ? {} : T;
-export type MergePart<T, Base> = unknown extends T ? Base : Base & T;
-/** Collapse intersections so `Omit`/`keyof` treat the result as one object type. */
-export type Simplify<T> = [T] extends [infer U] ? {
-    [K in keyof U]: U[K];
-} : never;
-/**
- * Request prop: when schema input is `unknown` (e.g. zod coerce),
- * fall back to the validated output type.
- */
-type RequestPropType<TIn, TOut> = [unknown] extends [Exclude<TIn, undefined>] ? TOut : TIn;
-/**
- * Pre-parse request shape. Prefer input types (defaults → optional),
- * but replace `unknown` input props with output types.
- */
-export type RequestShape<TIn, TOut> = unknown extends TIn ? UnwrapPart<TOut> : Simplify<{
-    [K in keyof TIn]: K extends keyof TOut ? RequestPropType<TIn[K], TOut[K]> : TIn[K];
-}>;
-export type UnionToIntersection<U> = (U extends unknown ? (value: U) => void : never) extends (value: infer Value) => void ? Value : never;
-export type MiddlewareField<Middleware, Field extends MiddlewareFieldName> = Field extends "query" ? Middleware extends {
-    query: infer Query;
-} ? Query : {} : Field extends "params" ? Middleware extends {
-    params: infer Params;
-} ? Params : {} : Field extends "body" ? Middleware extends {
-    body: infer Body;
-} ? Body : {} : Field extends "state" ? Middleware extends {
-    state: infer State;
-} ? State : {} : {};
-export type MiddlewareInputField<Middleware, Field extends MiddlewareInputFieldName> = Middleware extends {
-    input: {
-        [K in Field]: infer V;
-    };
-} ? V : {};
-export type MergeMiddlewareField<Middlewares extends readonly unknown[], Field extends MiddlewareFieldName> = Middlewares extends readonly [] ? {} : Middlewares extends readonly [infer Head, ...infer Tail] ? MiddlewareField<Head, Field> & MergeMiddlewareField<Tail, Field> : MiddlewareField<Middlewares[number], Field>;
-export type MergeMiddlewareInputField<Middlewares extends readonly unknown[], Field extends MiddlewareInputFieldName> = Middlewares extends readonly [] ? {} : Middlewares extends readonly [infer Head, ...infer Tail] ? MiddlewareInputField<Head, Field> & MergeMiddlewareInputField<Tail, Field> : MiddlewareInputField<Middlewares[number], Field>;
-export type RuntimeContextFields = {
-    request: Request;
-    method: Method;
-    url: URL;
-    headers: TaserHeaders;
-    cookies: TaserCookieJar;
-    var: Record<string, unknown>;
-};
-export type UnitRuntimeContext = Omit<RuntimeContextFields, "var">;

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

@@ -1,71 +0,0 @@
-import { MiddlewareDefinition as CoreMiddlewareDefinition, TaserCookieJar, TaserHeaders } from '@taserjs/router-core';
-import { RequestShape, Simplify, UnitRuntimeContext, UnwrapPart } from './type-utils.js';
-import { ReturnsMap } from './returns.js';
-import { Schema } from './schema.js';
-export type { HttpMethod, Method } from './type-utils.js';
-export type { EmptyReturns, MergeReturns, ReturnsMap, HandlerReply, HasReturns, StatusCode, ValidHandlerReply, EnforceHandlerReply, } from './returns.js';
-/** Default empty app context for standalone units without a bound router instance. */
-export type EmptyAppContext = Record<never, never>;
-export type ValidatorParts = {
-    query?: unknown;
-    params?: unknown;
-    body?: unknown;
-    queryIn?: unknown;
-    paramsIn?: unknown;
-    bodyIn?: unknown;
-};
-export declare const StateBrand: unique symbol;
-export type NextResult<TState = unknown> = Response & {
-    readonly [StateBrand]?: TState;
-};
-export type ExtractStateFromUnion<T> = T extends {
-    readonly [StateBrand]?: infer S;
-} ? [S] extends [never] ? never : [unknown] extends [S] ? {} : S : never;
-export type ExtractState<T> = [ExtractStateFromUnion<Awaited<T>>] extends [never] ? {} : ExtractStateFromUnion<Awaited<T>>;
-export type IsUnknown<T> = [unknown] extends [T] ? true : false;
-export type NextFn<TExpectedState = unknown> = IsUnknown<TExpectedState> extends true ? <S extends Record<string, unknown> = {}>(state?: S) => Promise<NextResult<S>> : (state: TExpectedState) => Promise<NextResult<TExpectedState>>;
-export type MiddlewareDefinition = CoreMiddlewareDefinition<ReturnsMap>;
-export type MiddlewareReturnFromParts<TQuery, TParams, TBody, TState, TQueryIn = TQuery, TParamsIn = TParams, TBodyIn = TBody> = {
-    query: UnwrapPart<TQuery>;
-    params: UnwrapPart<TParams>;
-    body: UnwrapPart<TBody>;
-    state: UnwrapPart<TState>;
-    /** Pre-parse shapes merged into route `$Infer.Input`. */
-    input: {
-        query: RequestShape<TQueryIn, TQuery>;
-        params: RequestShape<TParamsIn, TParams>;
-        body: RequestShape<TBodyIn, TBody>;
-    };
-};
-export type MiddlewareRequirements = {
-    query?: Record<string, unknown>;
-    params?: Record<string, unknown>;
-    body?: unknown;
-    state?: Record<string, unknown>;
-};
-export type DefineMiddlewareResult<TQuery, TParams, TBody, TState, R, TQueryIn = TQuery, TParamsIn = TParams, TBodyIn = TBody, TReturns extends ReturnsMap = {}, TLayout = null, TRequires extends MiddlewareRequirements = {}> = MiddlewareUnit<MiddlewareReturnFromParts<TQuery, TParams, TBody, IsUnknown<TState> extends true ? ExtractState<R> : TState, TQueryIn, TParamsIn, TBodyIn>, TReturns, TLayout, TRequires>;
-export type StandaloneMiddlewareContext<TQuery = unknown, TParams = unknown, TBody = unknown, TAppContext extends Record<string, unknown> = EmptyAppContext, TState = {}, TRequires extends MiddlewareRequirements = {}> = Simplify<TAppContext & UnitRuntimeContext & {
-    query: Simplify<UnwrapPart<TQuery> & (TRequires["query"] extends Record<string, unknown> ? TRequires["query"] : {})>;
-    params: Simplify<UnwrapPart<TParams> & (TRequires["params"] extends Record<string, unknown> ? TRequires["params"] : {})>;
-    body: Simplify<UnwrapPart<TBody> & (unknown extends TRequires["body"] ? {} : [TRequires["body"]] extends [undefined] ? {} : TRequires["body"])>;
-    state: Simplify<UnwrapPart<TState> & (TRequires["state"] extends Record<string, unknown> ? TRequires["state"] : {})>;
-    headers: TaserHeaders;
-    cookies: TaserCookieJar;
-}>;
-export declare const MiddlewareUnitBrand: unique symbol;
-export type MiddlewareUnit<TAcc = unknown, TReturns extends ReturnsMap = {}, TRequiredLayouts = unknown, TRequires extends MiddlewareRequirements = {}> = MiddlewareDefinition & {
-    readonly [MiddlewareUnitBrand]: true;
-    readonly __middlewareAcc: TAcc;
-    readonly __returns?: TReturns;
-    readonly __requiredLayouts?: TRequiredLayouts;
-    readonly __requirements?: TRequires;
-};
-export type MiddlewareUnitBuilder<TQuery = unknown, TParams = unknown, TBody = unknown, TReturns extends ReturnsMap = {}, TRequiredLayouts = unknown, TRequires extends MiddlewareRequirements = {}, TAppContext extends Record<string, unknown> = EmptyAppContext, TInheritedState = {}, TQueryIn = unknown, TParamsIn = unknown, TBodyIn = unknown, TExpectedState = unknown> = MiddlewareUnit<MiddlewareReturnFromParts<TQuery, TParams, TBody, IsUnknown<TExpectedState> extends true ? {} : TExpectedState, TQueryIn, TParamsIn, TBodyIn>, TReturns, TRequiredLayouts, TRequires> & {
-    query<Q, QIn = unknown>(schema: Schema<Q, QIn>): MiddlewareUnitBuilder<Q, TParams, TBody, TReturns, TRequiredLayouts, TRequires, TAppContext, TInheritedState, QIn, TParamsIn, TBodyIn, TExpectedState>;
-    params<P, PIn = unknown>(schema: Schema<P, PIn>): MiddlewareUnitBuilder<TQuery, P, TBody, TReturns, TRequiredLayouts, TRequires, TAppContext, TInheritedState, TQueryIn, PIn, TBodyIn, TExpectedState>;
-    body<B, BIn = unknown>(schema: Schema<B, BIn>): MiddlewareUnitBuilder<TQuery, TParams, B, TReturns, TRequiredLayouts, TRequires, TAppContext, TInheritedState, TQueryIn, TParamsIn, BIn, TExpectedState>;
-    body<Mode extends "json" | "form" | "urlencoded", B, BIn = unknown>(mode: Mode, schema: Schema<B, BIn>): MiddlewareUnitBuilder<TQuery, TParams, B, TReturns, TRequiredLayouts, TRequires, TAppContext, TInheritedState, TQueryIn, TParamsIn, BIn, TExpectedState>;
-    returns<const M extends ReturnsMap>(map: M): MiddlewareUnitBuilder<TQuery, TParams, TBody, Omit<TReturns, keyof M> & M, TRequiredLayouts, TRequires, TAppContext, TInheritedState, TQueryIn, TParamsIn, TBodyIn, TExpectedState>;
-    requires<Requires extends MiddlewareRequirements>(): MiddlewareUnitBuilder<TQuery, TParams, TBody, TReturns, TRequiredLayouts, TRequires & Requires, TAppContext, TInheritedState, TQueryIn, TParamsIn, TBodyIn, TExpectedState>;
-    handler<R>(fn: (ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext, TInheritedState, TRequires>, next: NextFn<TExpectedState>) => R): DefineMiddlewareResult<TQuery, TParams, TBody, IsUnknown<TExpectedState> extends true ? ExtractState<R> : TExpectedState, R, TQueryIn, TParamsIn, TBodyIn, TReturns, TRequiredLayouts, TRequires>;
-};

package/src/builder/app.ts

@@ -1,39 +0,0 @@
-import type { RouteManifestShape, TaserRuntime } from "@taserjs/router-core";
-
-export class TaserServeView<THasNotFound extends boolean = boolean> {
-  readonly fetch: (
-    request: Request,
-    env?: unknown,
-    executionCtx?: unknown,
-  ) => THasNotFound extends true
-    ? Promise<Response> | Response
-    : Promise<Response | undefined> | Response | undefined;
-
-  readonly request: (
-    path: string,
-    init?: RequestInit,
-  ) => THasNotFound extends true ? Promise<Response> : Promise<Response | undefined>;
-
-  constructor(protected readonly runtime: TaserRuntime<THasNotFound>) {
-    this.fetch = (request: Request, env?: unknown, executionCtx?: unknown) => {
-      return this.runtime.fetch(request, env, executionCtx as never);
-    };
-    this.request = (path: string, init?: RequestInit) => {
-      return this.runtime.request(path, init);
-    };
-  }
-}
-
-export class TaserApp<
-  TManifest extends RouteManifestShape = RouteManifestShape,
-  THasNotFound extends boolean = boolean,
-> extends TaserServeView<THasNotFound> {
-  readonly __manifest?: TManifest;
-
-  constructor(runtime: TaserRuntime<THasNotFound>, manifest?: TManifest) {
-    super(runtime);
-    if (manifest !== undefined) {
-      this.__manifest = manifest;
-    }
-  }
-}

package/src/builder/constants.ts

@@ -1,4 +0,0 @@
-/** Input schema keys validated by middleware and route handlers. Headers/cookies are parsed only. */
-export const SCHEMA_KEYS = ["query", "params", "body"] as const;
-
-export type SchemaKey = (typeof SCHEMA_KEYS)[number];

package/src/builder/middleware-unit.ts

@@ -1,71 +0,0 @@
-import type { BodyMode } from "@taserjs/router-core";
-
-import type { ReturnsMap } from "../types/returns.js";
-import type { Schema } from "../types/schema.js";
-import { pickDefinedSchemas, type SchemaValidators } from "../define/validators.js";
-
-class MiddlewareUnitBuilderImpl {
-  private readonly validators: SchemaValidators = {};
-  private bodyMode: BodyMode | undefined;
-  private returnsMap: ReturnsMap | undefined;
-  readonly __requiredLayouts: string | readonly string[] | undefined;
-  readonly __middlewareAcc: unknown = undefined;
-
-  constructor(requiredLayouts?: string | readonly string[]) {
-    this.__requiredLayouts = requiredLayouts;
-  }
-
-  query(schema: Schema<unknown>): this {
-    this.validators.query = schema;
-    return this;
-  }
-
-  params(schema: Schema<unknown>): this {
-    this.validators.params = schema;
-    return this;
-  }
-
-  body(modeOrSchema: BodyMode | Schema<unknown>, schema?: Schema<unknown>): this {
-    if (typeof modeOrSchema === "string") {
-      this.bodyMode = modeOrSchema as BodyMode;
-      if (schema !== undefined) {
-        this.validators.body = schema;
-      }
-    } else {
-      this.bodyMode = "json";
-      this.validators.body = modeOrSchema;
-    }
-    return this;
-  }
-
-  returns(map: ReturnsMap): this {
-    this.returnsMap = this.returnsMap ? { ...this.returnsMap, ...map } : { ...map };
-    return this;
-  }
-
-  requires(): this {
-    return this;
-  }
-
-  handler(fn: (ctx: any, next: any) => any) {
-    return this.toUnit(fn);
-  }
-
-  toUnit(fn?: (ctx: any, next: any) => any) {
-    const schemas = pickDefinedSchemas(this.validators);
-    return {
-      ...(fn ? { handler: fn } : {}),
-      ...schemas,
-      ...(this.bodyMode ? { bodyMode: this.bodyMode } : {}),
-      ...(this.returnsMap ? { returns: this.returnsMap, __returns: this.returnsMap } : {}),
-      ...(this.__requiredLayouts !== undefined
-        ? { __requiredLayouts: this.__requiredLayouts }
-        : {}),
-      __middlewareAcc: undefined as unknown,
-    };
-  }
-}
-
-export function createMiddlewareUnitBuilder(requiredLayouts?: string | readonly string[]) {
-  return new MiddlewareUnitBuilderImpl(requiredLayouts);
-}

package/src/builder/middleware.ts

@@ -1,23 +0,0 @@
-import type { LayoutId, MiddlewareBuilder } from "../types/index.js";
-import type { MiddlewareDefinition } from "../types/units.js";
-import { normalizeMiddlewareDefinition } from "./normalize.js";
-
-class MiddlewareBuilderImpl<Layout extends LayoutId> {
-  readonly layout: Layout;
-  readonly middlewares: MiddlewareDefinition[] = [];
-
-  constructor(layout: Layout) {
-    this.layout = layout;
-  }
-
-  use(definition: MiddlewareDefinition | ((ctx: any, next: any) => any)): this {
-    this.middlewares.push(normalizeMiddlewareDefinition(definition));
-    return this;
-  }
-}
-
-export function createMiddleware<const Layout extends LayoutId>(
-  layout: Layout,
-): MiddlewareBuilder<Layout, readonly []> {
-  return new MiddlewareBuilderImpl(layout) as unknown as MiddlewareBuilder<Layout, readonly []>;
-}

package/src/builder/normalize.ts

@@ -1,13 +0,0 @@
-import type { MiddlewareDefinition } from "../types/units.js";
-
-export function normalizeMiddlewareDefinition(
-  definition: MiddlewareDefinition | ((ctx: any, next: any) => any),
-): MiddlewareDefinition {
-  if (typeof definition === "function") {
-    return { handler: definition as any };
-  }
-  if (typeof (definition as any)?.toUnit === "function") {
-    return (definition as any).toUnit();
-  }
-  return definition;
-}

package/src/builder/route.ts

@@ -1,137 +0,0 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec";
-import {
-  collectReturnsFromDefinitions,
-  hasInputSchemas,
-  mergeReturnsMaps,
-  withAuto422,
-} from "@taserjs/router-utils";
-import type { BodyMode } from "@taserjs/router-core";
-
-import type {
-  Method,
-  RouteBuilder,
-  RoutePath,
-  ReturnsMap,
-  ValidatorParts,
-  Schema,
-} from "../types/index.js";
-import type { HttpMethod, MiddlewareDefinition } from "../types/units.js";
-import { pickDefinedSchemas, type SchemaValidators } from "../define/validators.js";
-import { normalizeMiddlewareDefinition } from "./normalize.js";
-
-function buildRouteReturnsWith422(args: {
-  middlewareReturns: ReturnsMap;
-  routeReturns: ReturnsMap;
-  schemas: {
-    query?: unknown;
-    params?: unknown;
-    body?: unknown;
-    middlewares?: readonly MiddlewareDefinition[];
-  };
-}): Record<number, StandardSchemaV1> | undefined {
-  const merged = mergeReturnsMaps(
-    args.middlewareReturns as Record<number, StandardSchemaV1>,
-    args.routeReturns as Record<number, StandardSchemaV1>,
-  );
-  const with422 = withAuto422(merged, hasInputSchemas(args.schemas));
-  return Object.keys(with422).length > 0 ? with422 : undefined;
-}
-
-function buildRouteBase(
-  path: string,
-  method: HttpMethod | "ANY" | "ALL",
-  methods: readonly HttpMethod[] | undefined,
-  middlewares: MiddlewareDefinition[],
-) {
-  return {
-    path,
-    method,
-    ...(methods ? { methods: [...methods] } : {}),
-    middlewares: [...middlewares],
-  };
-}
-
-class RouteBuilderImpl {
-  readonly path: string;
-  readonly method: HttpMethod | "ANY" | "ALL";
-  readonly methods: readonly HttpMethod[] | undefined;
-  private readonly middlewares: MiddlewareDefinition[] = [];
-  private readonly routeReturns: Record<number, StandardSchemaV1> = {};
-  private readonly validators: SchemaValidators = {};
-  private bodyMode: BodyMode | undefined;
-
-  constructor(path: string, method: HttpMethod | "ANY" | "ALL", methods?: readonly HttpMethod[]) {
-    this.path = path;
-    this.method = method;
-    this.methods = methods;
-  }
-
-  query(schema: Schema<unknown>): this {
-    this.validators.query = schema;
-    return this;
-  }
-
-  params(schema: Schema<unknown>): this {
-    this.validators.params = schema;
-    return this;
-  }
-
-  body(modeOrSchema: BodyMode | Schema<unknown>, schema?: Schema<unknown>): this {
-    if (typeof modeOrSchema === "string") {
-      this.bodyMode = modeOrSchema as BodyMode;
-      if (schema !== undefined) {
-        this.validators.body = schema;
-      }
-    } else {
-      this.bodyMode = "json";
-      this.validators.body = modeOrSchema;
-    }
-    return this;
-  }
-
-  returns(map: ReturnsMap): this {
-    Object.assign(this.routeReturns, map);
-    return this;
-  }
-
-  use(definition: MiddlewareDefinition | ((ctx: any, next: any) => any)): this {
-    this.middlewares.push(normalizeMiddlewareDefinition(definition));
-    return this;
-  }
-
-  handler(fn: (ctx: unknown) => Response | Promise<Response>) {
-    const routeSchemas = pickDefinedSchemas(this.validators);
-    const base = buildRouteBase(this.path, this.method, this.methods, this.middlewares);
-
-    const returns = buildRouteReturnsWith422({
-      middlewareReturns: collectReturnsFromDefinitions(this.middlewares),
-      routeReturns: this.routeReturns,
-      schemas: {
-        ...this.validators,
-        middlewares: this.middlewares,
-      },
-    });
-
-    return {
-      ...base,
-      handler: fn,
-      ...routeSchemas,
-      ...(this.bodyMode ? { bodyMode: this.bodyMode } : {}),
-      ...(returns ? { returns } : {}),
-    };
-  }
-}
-
-/** Shared internal builder — not part of the public `@taserjs/router` API. */
-export function createRouteBuilder(
-  path: string,
-  method: HttpMethod | "ANY" | "ALL",
-  methods?: readonly HttpMethod[],
-): RouteBuilder<RoutePath, Method, readonly [], ValidatorParts> {
-  return new RouteBuilderImpl(path, method, methods) as unknown as RouteBuilder<
-    RoutePath,
-    Method,
-    readonly [],
-    ValidatorParts
-  >;
-}

package/src/builder/router.ts

@@ -1,144 +0,0 @@
-import {
-  createTaserRuntime,
-  type NotFoundHandler,
-  type OnErrorHandler,
-  type RouteManifestShape,
-} from "@taserjs/router-core";
-import { isPromise, normalizeOnError } from "@taserjs/router-utils";
-
-import { TaserApp } from "./app.js";
-import type { ContextDefinition, CreateTaserAppOptions, OnErrorOptions } from "../types/app.js";
-import type { EmptyAppContext } from "../types/units.js";
-import type { ReturnsMap } from "../types/returns.js";
-
-function toOnErrorHandler(
-  onErrorOptions: OnErrorOptions | OnErrorOptions["handle"],
-): OnErrorHandler {
-  return normalizeOnError(onErrorOptions);
-}
-
-type RouterState = {
-  options: CreateTaserAppOptions;
-  contextDef: ContextDefinition<Record<string, unknown>, Record<string, unknown>>;
-  onError?: OnErrorHandler;
-  notFound?: NotFoundHandler;
-};
-
-const emptyContext: ContextDefinition<Record<string, unknown>, Record<string, unknown>> = {};
-
-export class TaserRouter<
-  TAppContext extends Record<string, unknown> = EmptyAppContext,
-  THasNotFound extends boolean = false,
-> {
-  private readonly state: RouterState;
-  readonly $Infer!: {
-    Context: TAppContext;
-  };
-
-  constructor(options: CreateTaserAppOptions = {}, state?: Partial<Omit<RouterState, "options">>) {
-    this.state = {
-      options,
-      contextDef: state?.contextDef ?? emptyContext,
-      ...(state?.onError !== undefined ? { onError: state.onError } : {}),
-      ...(state?.notFound !== undefined ? { notFound: state.notFound } : {}),
-    };
-  }
-
-  context<TBoot extends Record<string, unknown>, TReq extends Record<string, unknown>>(
-    definition: ContextDefinition<TBoot, TReq>,
-  ): TaserRouter<TBoot & TReq, THasNotFound> {
-    this.state.contextDef = definition;
-    return this as unknown as TaserRouter<TBoot & TReq, THasNotFound>;
-  }
-
-  onError<TResponses extends ReturnsMap = ReturnsMap>(
-    options: OnErrorOptions<TResponses> | OnErrorOptions<TResponses>["handle"],
-  ): this {
-    this.state.onError = toOnErrorHandler(options);
-    return this;
-  }
-
-  notFound(
-    handler: (ctx: unknown) => Response | Promise<Response> | unknown,
-  ): TaserRouter<TAppContext, true> {
-    this.state.notFound = (ctx) => handler(ctx);
-    return this as unknown as TaserRouter<TAppContext, true>;
-  }
-
-  create<const TManifest extends RouteManifestShape>(
-    manifest: TManifest,
-    runtimeOptions?: { basePath?: string },
-  ): TaserApp<TManifest, THasNotFound> {
-    const definition = this.state.contextDef;
-    const validateResponse = this.state.options.response?.validate ?? true;
-    const onValidationFailure = this.state.options.response?.onValidationFailure;
-    const basePath = runtimeOptions?.basePath;
-
-    const hasCustomContext = definition.boot !== undefined || definition.request !== undefined;
-    let bootContextResolved: Record<string, unknown> | undefined;
-    let bootPromise: Promise<Record<string, unknown>> | undefined;
-
-    if (definition.boot !== undefined) {
-      const bootResult = definition.boot();
-      if (isPromise(bootResult)) {
-        bootPromise = bootResult.then((ctx) => {
-          bootContextResolved = (ctx ?? {}) as Record<string, unknown>;
-          return bootContextResolved;
-        });
-      } else {
-        bootContextResolved = (bootResult ?? {}) as Record<string, unknown>;
-      }
-    } else if (hasCustomContext) {
-      bootContextResolved = {};
-    }
-
-    const contextFactory = hasCustomContext
-      ? (req?: Request) => {
-          if (bootPromise !== undefined && bootContextResolved === undefined) {
-            return bootPromise.then(async (bootContext) => {
-              if (!definition.request) {
-                return { ...bootContext };
-              }
-              const requestResult = definition.request(req!);
-              const requestContext = isPromise(requestResult) ? await requestResult : requestResult;
-              return { ...bootContext, ...requestContext };
-            });
-          }
-
-          const bootContext = bootContextResolved ?? {};
-          if (!definition.request) {
-            return { ...bootContext };
-          }
-
-          const requestResult = definition.request(req!);
-          if (isPromise(requestResult)) {
-            return requestResult.then((requestContext) => ({
-              ...bootContext,
-              ...requestContext,
-            }));
-          }
-
-          return { ...bootContext, ...(requestResult as Record<string, unknown>) };
-        }
-      : () => ({});
-
-    const runtime = createTaserRuntime(manifest, contextFactory, {
-      ...(basePath !== undefined ? { basePath } : {}),
-      response: {
-        validate: validateResponse,
-        ...(onValidationFailure !== undefined ? { onValidationFailure } : {}),
-      },
-      ...(this.state.onError !== undefined ? { onError: this.state.onError } : {}),
-      ...(this.state.notFound !== undefined ? { notFound: this.state.notFound } : {}),
-      ...(this.state.options.cookies !== undefined ? { cookies: this.state.options.cookies } : {}),
-    });
-
-    return new TaserApp(runtime, manifest) as unknown as TaserApp<TManifest, THasNotFound>;
-  }
-}
-
-export function createTaserApp(
-  options: CreateTaserAppOptions = {},
-): TaserRouter<EmptyAppContext, false> {
-  return new TaserRouter<EmptyAppContext, false>(options);
-}