@taserjs/router 0.0.2 → 0.0.4

package/src/route.ts

@@ -1,62 +1,59 @@
-import type { StandardSchemaV1 } from '@standard-schema/spec'
+import type { StandardSchemaV1 } from "@standard-schema/spec";
 import {
   collectReturnsFromDefinitions,
   hasInputSchemas,
   mergeReturnsMaps,
   withAuto422,
-} from '@taserjs/router-utils'
+} from "@taserjs/router-utils";
 
-import type { Method, RouteBuilder, RoutePath, ReturnsMap, ValidatorParts } from './types/index.js'
-import type { HttpMethod, MiddlewareDefinition } from './types/units.js'
-import { isHandlerUnit } from './types/units.js'
-import { HANDLER_SCHEMA_KEY_MAP } from './constants.js'
-import {
-  pickDefinedSchemas,
-  type SchemaValidators,
-} from './define/validators.js'
+import type { Method, RouteBuilder, RoutePath, ReturnsMap, ValidatorParts } from "./types/index.js";
+import type { HttpMethod, MiddlewareDefinition } from "./types/units.js";
+import { isHandlerUnit } from "./types/units.js";
+import { HANDLER_SCHEMA_KEY_MAP } from "./constants.js";
+import { pickDefinedSchemas, type SchemaValidators } from "./define/validators.js";
 
 function toUtilsMap(map: ReturnsMap | undefined): Record<number, StandardSchemaV1> {
   if (!map) {
-    return {}
+    return {};
   }
-  const out: Record<number, StandardSchemaV1> = {}
+  const out: Record<number, StandardSchemaV1> = {};
   for (const [key, schema] of Object.entries(map)) {
     if (schema !== undefined) {
-      out[Number(key)] = schema
+      out[Number(key)] = schema;
     }
   }
-  return out
+  return out;
 }
 
 function buildEffectiveReturns(args: {
-  middlewareReturns: ReturnsMap
-  routeReturns: ReturnsMap
-  handlerMiddlewareReturns: ReturnsMap
-  handlerReturns: ReturnsMap | undefined
+  middlewareReturns: ReturnsMap;
+  routeReturns: ReturnsMap;
+  handlerMiddlewareReturns: ReturnsMap;
+  handlerReturns: ReturnsMap | undefined;
   schemas: {
-    query?: unknown
-    params?: unknown
-    body?: unknown
-    handlerQuery?: unknown
-    handlerParams?: unknown
-    handlerBody?: unknown
-    middlewares?: readonly MiddlewareDefinition[]
-    handlerMiddlewares?: readonly MiddlewareDefinition[]
-  }
+    query?: unknown;
+    params?: unknown;
+    body?: unknown;
+    handlerQuery?: unknown;
+    handlerParams?: unknown;
+    handlerBody?: unknown;
+    middlewares?: readonly MiddlewareDefinition[];
+    handlerMiddlewares?: readonly MiddlewareDefinition[];
+  };
 }): Record<number, StandardSchemaV1> | undefined {
   const merged = mergeReturnsMaps(
     toUtilsMap(args.middlewareReturns),
     toUtilsMap(args.routeReturns),
     toUtilsMap(args.handlerMiddlewareReturns),
     toUtilsMap(args.handlerReturns),
-  )
-  const with422 = withAuto422(merged, hasInputSchemas(args.schemas))
-  return Object.keys(with422).length > 0 ? with422 : undefined
+  );
+  const with422 = withAuto422(merged, hasInputSchemas(args.schemas));
+  return Object.keys(with422).length > 0 ? with422 : undefined;
 }
 
 function buildRouteBase(
   path: string,
-  method: HttpMethod | 'ANY' | 'ALL',
+  method: HttpMethod | "ANY" | "ALL",
   methods: readonly HttpMethod[] | undefined,
   middlewares: MiddlewareDefinition[],
 ) {
@@ -65,36 +62,36 @@ function buildRouteBase(
     method,
     ...(methods ? { methods: [...methods] } : {}),
     middlewares: [...middlewares],
-  }
+  };
 }
 
 /** Shared internal builder — not part of the public `@taserjs/router` API. */
 export function createRouteBuilder(
   path: string,
-  method: HttpMethod | 'ANY' | 'ALL',
+  method: HttpMethod | "ANY" | "ALL",
   validators: SchemaValidators = {},
   methods?: readonly HttpMethod[],
 ): RouteBuilder<RoutePath, Method, readonly [], ValidatorParts> {
-  const middlewares: MiddlewareDefinition[] = []
-  let routeReturns: Record<number, StandardSchemaV1> = {}
+  const middlewares: MiddlewareDefinition[] = [];
+  let routeReturns: Record<number, StandardSchemaV1> = {};
 
   const builder = {
     path,
     method,
     returns(map: ReturnsMap) {
-      routeReturns = { ...routeReturns, ...toUtilsMap(map) }
-      return builder
+      routeReturns = { ...routeReturns, ...toUtilsMap(map) };
+      return builder;
     },
     use(definition: MiddlewareDefinition) {
-      middlewares.push(definition)
-      return builder
+      middlewares.push(definition);
+      return builder;
     },
     handler(fnOrUnit: ((ctx: unknown) => unknown) | unknown) {
-      const routeSchemas = pickDefinedSchemas(validators)
-      const base = buildRouteBase(path, method, methods, middlewares)
+      const routeSchemas = pickDefinedSchemas(validators);
+      const base = buildRouteBase(path, method, methods, middlewares);
 
       if (isHandlerUnit(fnOrUnit)) {
-        const handlerSchemas = pickDefinedSchemas(fnOrUnit, HANDLER_SCHEMA_KEY_MAP)
+        const handlerSchemas = pickDefinedSchemas(fnOrUnit, HANDLER_SCHEMA_KEY_MAP);
         const returns = buildEffectiveReturns({
           middlewareReturns: collectReturnsFromDefinitions(middlewares),
           routeReturns: routeReturns,
@@ -108,7 +105,7 @@ export function createRouteBuilder(
             middlewares,
             handlerMiddlewares: fnOrUnit.middlewares,
           },
-        })
+        });
 
         return {
           ...base,
@@ -117,7 +114,7 @@ export function createRouteBuilder(
           ...routeSchemas,
           ...handlerSchemas,
           ...(returns ? { returns } : {}),
-        }
+        };
       }
 
       const returns = buildEffectiveReturns({
@@ -129,7 +126,7 @@ export function createRouteBuilder(
           ...validators,
           middlewares,
         },
-      })
+      });
 
       return {
         ...base,
@@ -137,9 +134,9 @@ export function createRouteBuilder(
         handler: fnOrUnit as (ctx: unknown) => Response | Promise<Response>,
         ...routeSchemas,
         ...(returns ? { returns } : {}),
-      }
+      };
     },
-  }
+  };
 
-  return builder as unknown as RouteBuilder<RoutePath, Method, readonly [], ValidatorParts>
+  return builder as unknown as RouteBuilder<RoutePath, Method, readonly [], ValidatorParts>;
 }

package/src/stream.ts

@@ -1,7 +1 @@
-export {
-  blob,
-  buffer,
-  file,
-  pipe,
-  stream,
-} from '@taserjs/router-utils'
+export { blob, buffer, file, pipe, stream } from "@taserjs/router-utils";

package/src/taser-app.ts

@@ -1,15 +1,15 @@
-import type { TaserRuntime } from '@taserjs/router-core'
-import type { RouteManifestShape } from '@taserjs/router-core'
+import type { TaserRuntime } from "@taserjs/router-core";
+import type { RouteManifestShape } from "@taserjs/router-core";
 
 class TaserServeView {
-  constructor(protected readonly runtime: TaserRuntime) { }
+  constructor(protected readonly runtime: TaserRuntime) {}
 
   fetch(request: Request, env?: unknown, executionCtx?: unknown): Promise<Response> {
-    return this.runtime.fetch(request, env, executionCtx as never)
+    return this.runtime.fetch(request, env, executionCtx as never);
   }
 
   native(native: unknown): TaserNativeBound {
-    return new TaserNativeBound(this.runtime, native)
+    return new TaserNativeBound(this.runtime, native);
   }
 }
 
@@ -17,27 +17,22 @@ export class TaserNativeBound {
   constructor(
     private readonly runtime: TaserRuntime,
     private readonly boundNative: unknown,
-  ) { }
+  ) {}
 
   fetch(request: Request, env?: unknown, executionCtx?: unknown): Promise<Response> {
-    return this.runtime.native(this.boundNative).fetch(request, env, executionCtx as never)
+    return this.runtime.native(this.boundNative).fetch(request, env, executionCtx as never);
   }
 }
 
-export class TaserMountedApp extends TaserServeView { }
-
-export class TaserApp<TManifest extends RouteManifestShape = RouteManifestShape> extends TaserServeView {
-  readonly __manifest?: TManifest
+export class TaserApp<
+  TManifest extends RouteManifestShape = RouteManifestShape,
+> extends TaserServeView {
+  readonly __manifest?: TManifest;
 
   constructor(runtime: TaserRuntime, manifest?: TManifest) {
-    super(runtime)
+    super(runtime);
     if (manifest !== undefined) {
-      this.__manifest = manifest
+      this.__manifest = manifest;
     }
   }
-
-  base(prefix: string): TaserMountedApp {
-    this.runtime.registerRoutePrefix(prefix)
-    return new TaserMountedApp(this.runtime)
-  }
 }

package/src/taser-router.ts

@@ -3,8 +3,8 @@ import {
   type NotFoundHandler,
   type OnErrorHandler,
   type RouteManifestShape,
-} from '@taserjs/router-core'
-import { normalizeOnError } from '@taserjs/router-utils'
+} from "@taserjs/router-core";
+import { normalizeOnError } from "@taserjs/router-utils";
 
 import {
   createAllRoute,
@@ -16,145 +16,150 @@ import {
   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 type {
-  ContextDefinition,
-  CreateTaserAppOptions,
-  OnErrorOptions,
-} from './types/app.js'
-import type { AppContext } from './types/units.js'
-import type { HandlerBuilder, LayoutId, MiddlewareBuilder } from './types/index.js'
-import type { Schema } from './types/schema.js'
+} from "./factories.js";
+import { defineHandler } from "./define/handler.js";
+import { createMiddleware } from "./middleware.js";
+import { TaserApp } from "./taser-app.js";
+import type { ContextDefinition, CreateTaserAppOptions, OnErrorOptions } from "./types/app.js";
+import type { AppContext } from "./types/units.js";
+import type { HandlerBuilder, LayoutId, MiddlewareBuilder } from "./types/index.js";
+import type { Schema } from "./types/schema.js";
 import type {
   CreateAllRoute,
   CreateAnyRoute,
   CreateWithBodyRoute,
   CreateWithoutBodyRoute,
-} from './factories.js'
+} from "./factories.js";
 
 function toOnErrorHandler(
-  onErrorOptions: OnErrorOptions | OnErrorOptions['handle'],
+  onErrorOptions: OnErrorOptions | OnErrorOptions["handle"],
 ): OnErrorHandler {
-  return normalizeOnError(onErrorOptions)
+  return normalizeOnError(onErrorOptions);
 }
 
 type RouterState = {
-  options: CreateTaserAppOptions
-  contextDef: ContextDefinition<Record<string, unknown>, Record<string, unknown>>
-  onError?: OnErrorHandler
-  notFound?: NotFoundHandler
-}
+  options: CreateTaserAppOptions;
+  contextDef: ContextDefinition<Record<string, unknown>, Record<string, unknown>>;
+  onError?: OnErrorHandler;
+  notFound?: NotFoundHandler;
+};
 
-const emptyContext: ContextDefinition<Record<string, unknown>, Record<string, unknown>> = {}
+const emptyContext: ContextDefinition<Record<string, unknown>, Record<string, unknown>> = {};
 
 export class TaserRouter<TAppContext extends Record<string, unknown> = AppContext> {
-  private readonly state: RouterState
+  private readonly state: RouterState;
 
-  constructor(options: CreateTaserAppOptions = {}, state?: Partial<Omit<RouterState, 'options'>>) {
+  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> {
-    this.state.contextDef = definition
-    return this as unknown as TaserRouter<TBoot & TReq>
+  context<TBoot extends Record<string, unknown>, TReq extends Record<string, unknown>>(
+    definition: ContextDefinition<TBoot, TReq>,
+  ): TaserRouter<TBoot & TReq> {
+    this.state.contextDef = definition;
+    return this as unknown as TaserRouter<TBoot & TReq>;
   }
 
-  onError<TResponses extends import('./types/returns.js').ReturnsMap = import('./types/returns.js').ReturnsMap>(
-    options: OnErrorOptions<TResponses> | OnErrorOptions<TResponses>['handle'],
-  ): this {
-    this.state.onError = toOnErrorHandler(options)
-    return this
+  onError<
+    TResponses extends import("./types/returns.js").ReturnsMap =
+      import("./types/returns.js").ReturnsMap,
+  >(options: OnErrorOptions<TResponses> | OnErrorOptions<TResponses>["handle"]): this {
+    this.state.onError = toOnErrorHandler(options);
+    return this;
   }
 
-  notFound(
-    handler: (ctx: unknown) => Response | Promise<Response> | unknown,
-  ): this {
-    this.state.notFound = ctx => handler(ctx)
-    return this
+  notFound(handler: (ctx: unknown) => Response | Promise<Response> | unknown): this {
+    this.state.notFound = (ctx) => handler(ctx);
+    return this;
   }
 
-  get: CreateWithoutBodyRoute<'GET', TAppContext> = createGetRoute as CreateWithoutBodyRoute<'GET', TAppContext>
-  post: CreateWithBodyRoute<'POST', TAppContext> = createPostRoute as CreateWithBodyRoute<'POST', TAppContext>
-  put: CreateWithBodyRoute<'PUT', TAppContext> = createPutRoute as CreateWithBodyRoute<'PUT', TAppContext>
-  patch: CreateWithBodyRoute<'PATCH', TAppContext> = createPatchRoute as CreateWithBodyRoute<'PATCH', TAppContext>
-  delete: CreateWithoutBodyRoute<'DELETE', TAppContext> = createDeleteRoute as CreateWithoutBodyRoute<'DELETE', TAppContext>
-  options: CreateWithoutBodyRoute<'OPTIONS', TAppContext> = createOptionsRoute as CreateWithoutBodyRoute<'OPTIONS', TAppContext>
-  head: CreateWithoutBodyRoute<'HEAD', TAppContext> = createHeadRoute as CreateWithoutBodyRoute<'HEAD', TAppContext>
-  any: CreateAnyRoute<TAppContext> = createAnyRoute as CreateAnyRoute<TAppContext>
-  all: CreateAllRoute<TAppContext> = createAllRoute as CreateAllRoute<TAppContext>
-
-  middleware<const Layout extends LayoutId>(layout: Layout): MiddlewareBuilder<Layout, readonly [], TAppContext> {
-    return createMiddleware(layout) as MiddlewareBuilder<Layout, readonly [], TAppContext>
+  get: CreateWithoutBodyRoute<"GET", TAppContext> = createGetRoute as CreateWithoutBodyRoute<
+    "GET",
+    TAppContext
+  >;
+  post: CreateWithBodyRoute<"POST", TAppContext> = createPostRoute as CreateWithBodyRoute<
+    "POST",
+    TAppContext
+  >;
+  put: CreateWithBodyRoute<"PUT", TAppContext> = createPutRoute as CreateWithBodyRoute<
+    "PUT",
+    TAppContext
+  >;
+  patch: CreateWithBodyRoute<"PATCH", TAppContext> = createPatchRoute as CreateWithBodyRoute<
+    "PATCH",
+    TAppContext
+  >;
+  delete: CreateWithoutBodyRoute<"DELETE", TAppContext> =
+    createDeleteRoute as CreateWithoutBodyRoute<"DELETE", TAppContext>;
+  options: CreateWithoutBodyRoute<"OPTIONS", TAppContext> =
+    createOptionsRoute as CreateWithoutBodyRoute<"OPTIONS", TAppContext>;
+  head: CreateWithoutBodyRoute<"HEAD", TAppContext> = createHeadRoute as CreateWithoutBodyRoute<
+    "HEAD",
+    TAppContext
+  >;
+  any: CreateAnyRoute<TAppContext> = createAnyRoute as CreateAnyRoute<TAppContext>;
+  all: CreateAllRoute<TAppContext> = createAllRoute as CreateAllRoute<TAppContext>;
+
+  middleware<const Layout extends LayoutId>(
+    layout: Layout,
+  ): MiddlewareBuilder<Layout, readonly [], TAppContext> {
+    return createMiddleware(layout) as MiddlewareBuilder<Layout, readonly [], TAppContext>;
   }
 
-  defineHandler<
-    TQuery = unknown,
-    TParams = unknown,
-    TBody = unknown,
-  >(
-    options?: {
-      query?: Schema<TQuery>
-      params?: Schema<TParams>
-      body?: Schema<TBody>
-    },
-  ): HandlerBuilder<
+  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 },
+    { query: TQuery; params: TParams; body: TBody },
     {},
     TAppContext
   > {
     return options === undefined
       ? defineHandler<TAppContext>()
-      : defineHandler<TAppContext>(options)
-  }
-
-  defineMiddleware(): ReturnType<typeof defineMiddleware<TAppContext>> {
-    return defineMiddleware<TAppContext>()
+      : defineHandler<TAppContext>(options);
   }
 
   create<const TManifest extends RouteManifestShape>(manifest: TManifest): TaserApp<TManifest> {
-    const definition = this.state.contextDef
-    const validateResponse = this.state.options.response?.validate ?? true
-    const onValidationFailure = this.state.options.response?.onValidationFailure
-    const bootPromise = Promise.resolve(
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-      definition.boot?.() ?? ({} as Record<string, unknown>),
-    )
-
-    const runtime = createTaserRuntime(
-      manifest,
-      async ({ native }) => {
-        const bootContext = await bootPromise
-        const requestContext = await definition.request?.({ native }) ?? {}
-        return { ...bootContext, ...requestContext }
-      },
-      {
-        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 } : {}),
+    const definition = this.state.contextDef;
+    const validateResponse = this.state.options.response?.validate ?? true;
+    const onValidationFailure = this.state.options.response?.onValidationFailure;
+    const basePath = this.state.options.basePath;
+
+    const hasCustomContext = definition.boot !== undefined || definition.request !== undefined;
+    const bootPromise = hasCustomContext
+      ? Promise.resolve(definition.boot?.() ?? ({} as Record<string, unknown>))
+      : undefined;
+
+    const contextFactory = hasCustomContext
+      ? async ({ native }: { native?: unknown } = {}) => {
+          const bootContext = (await bootPromise) ?? {};
+          const requestContext = (await definition.request?.({ native: native as never })) ?? {};
+          return { ...bootContext, ...requestContext };
+        }
+      : () => ({});
+
+    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)
+    return new TaserApp(runtime, manifest);
   }
 }
 
 export function createTaserApp(options: CreateTaserAppOptions = {}): TaserRouter {
-  return new TaserRouter(options)
+  return new TaserRouter(options);
 }

package/src/types/app.ts

@@ -1,53 +1,51 @@
-import type { ResponseValidationFailureHandler } from '@taserjs/router-utils'
+import type { ResponseValidationFailureHandler } from "@taserjs/router-utils";
 
-import type { TaserApp } from '../taser-app.js'
-import type { ReturnsMap } from './returns.js'
-import type { Schema } from './schema.js'
+import type { TaserApp } from "../taser-app.js";
+import type { ReturnsMap } from "./returns.js";
+import type { Schema } from "./schema.js";
 
 export type CreateTaserAppOptions = {
+  basePath?: string;
   response?: {
     /** Validate handler replies against returns maps. Default true. */
-    validate?: boolean
-    onValidationFailure?: ResponseValidationFailureHandler
-  }
+    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
-  }
-}
+    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
-}
+  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>
-}
+  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>
+> = 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>
-}
+  responses?: TResponses;
+  handle: (error: unknown, ctx?: unknown) => Response | Promise<Response>;
+};
 
-export type InferAppManifest<TApp> = TApp extends TaserApp<infer TManifest> ? TManifest : never
+export type InferAppManifest<TApp> = TApp extends TaserApp<infer TManifest> ? TManifest : never;
 
 export type TaserHandler<TFrameworkApp> = {
   /**
@@ -55,11 +53,11 @@ export type TaserHandler<TFrameworkApp> = {
    * 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
-}
+  mount(pattern: string, frameworkApp: TFrameworkApp): void;
+};
 
-export type { RouteManifestShape } from '@taserjs/router-core'
+export type { RouteManifestShape } from "@taserjs/router-core";
 
-export type { Schema }
+export type { Schema };
 
-export type { TaserApp, TaserMountedApp, TaserNativeBound } from '../taser-app.js'
+export type { TaserApp, TaserNativeBound } from "../taser-app.js";