import { Hono } from "hono";import { swaggerUI } from "@hono/swagger-ui";import { cors } from "hono/cors";import { openAPIRouteHandler } from "hono-openapi";import { Effect } from "effect";import type { AppContext } from "../app-context";import type { ControllerRuntime } from "../core/effect-runtime";import { isHttpStatus } from "../core/errors";import { registerComputeRoutes } from "../modules/compute/routes";import { registerEngineRoutes } from "../modules/engines/routes";import { registerSystemRoutes } from "../modules/system/routes";import { registerModelsRoutes } from "../modules/models/routes"; import { registerAllProxyRoutes } from "../modules/proxy/routes";import { registerStudioRoutes } from "../modules/studio/routes";import { documentRoute, mergeRoutes, type ControllerRouteApp } from "./route-registrar";import {  createAuthMiddleware,  createMutatingRateLimitMiddleware,  createReadRateLimitMiddleware,} from "./security-middleware";import {  createControllerRequestObservabilityMiddleware,  TELEMETRY_SKIP_PATHS,} from "./observability-middleware";import {  controllerRuntimeMiddleware,  effectHandler,  effectMiddleware,  type ControllerEnvironment,} from "./effect-handler"; type ControllerApplication = ReturnType<typeof registerComputeRoutes> &  ReturnType<typeof registerSystemRoutes> &  ReturnType<typeof registerEngineRoutes> &  ReturnType<typeof registerModelsRoutes> &  ReturnType<typeof registerStudioRoutes> &  ReturnType<typeof registerAllProxyRoutes>; export const createApp = (  context: AppContext,  runtime: ControllerRuntime,): ControllerApplication => {  const app = new Hono<ControllerEnvironment>();  const allowedCorsOrigins = context.config.cors_origins ?? [];   app.use("*", controllerRuntimeMiddleware(runtime));   app.use(    "*",    cors({      origin: (origin) => (allowedCorsOrigins.includes(origin) ? origin : null),      allowMethods: ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],      allowHeaders: ["Authorization", "Content-Type", "X-API-Key"],      exposeHeaders: [        "X-RateLimit-Limit",        "X-RateLimit-Remaining",        "X-RateLimit-Reset",        "Retry-After",      ],      maxAge: 600,    }),  );   app.use(    "*",    effectMiddleware((ctx, next) =>      Effect.sync(() => {        if (!TELEMETRY_SKIP_PATHS.has(ctx.req.path)) {          context.logger.debug(`${ctx.req.method} ${ctx.req.path}`);        }      }).pipe(        Effect.andThen(          Effect.tryPromise({            try: () => next(),            catch: (error) => error,          }),        ),      ),    ),  );   app.use("*", createControllerRequestObservabilityMiddleware(context));  app.use("*", createMutatingRateLimitMiddleware(context));  app.use("*", createReadRateLimitMiddleware(context));  app.use("*", createAuthMiddleware(context));   const routes = mergeRoutes(    registerSystemRoutes(app, context),    registerComputeRoutes(app, context),    registerEngineRoutes(app, context),    registerModelsRoutes(app, context),    registerStudioRoutes(app, context),    registerAllProxyRoutes(app, context),    app.get(      "/health",      documentRoute,      effectHandler((ctx) => Effect.succeed(ctx.json({ status: "ok" }))),    ),  );   const documentedRoutes = mergeRoutes(    routes,    app.get(      "/api/spec",      openAPIRouteHandler(routes as ControllerRouteApp, {        includeEmptyPaths: true,        exclude: ["/*", "/api/spec", "/api/docs"],        documentation: {          info: {            title: "Local Studio API",            version: "2.0.0",            description: "Model lifecycle management for local and remote inference runtimes",          },          servers: [            {              url: `http://localhost:${context.config.port}`,              description: "Local Studio controller",            },          ],        },      }),    ),    app.get("/api/docs", swaggerUI({ url: "/api/spec" })),  );   documentedRoutes.notFound((ctx) => ctx.json({ detail: "Not Found" }, { status: 404 }));   documentedRoutes.onError((error, ctx) => {    if (isHttpStatus(error)) {      return Response.json({ detail: error.detail }, { status: error.status });    }    const name = (error as { name?: string })?.name ?? "";    const message = String(error);    if (      name === "AbortError" ||      message.includes("AbortError") ||      message.includes("connection was closed") ||      message.includes("ERR_STREAM_PREMATURE_CLOSE") ||      message.includes("Stream was cancelled") ||      message.includes("stream was cancelled") ||      message.includes("The operation was aborted") ||      message.includes("readable stream is cancelled")    ) {      context.logger.debug("client disconnected mid-request", {        method: ctx.req.method,        path: ctx.req.path,      });      return new Response(null, { status: 499 });    }    context.logger.error("Unhandled error", { error: message });    return ctx.json({ detail: "Internal Server Error" }, { status: 500 });  });   return documentedRoutes as ControllerApplication;};