// ---------------------------------------------------------------------------// Shared host-boot API foundation.//// Every product host (cloud, self-host, local) assembles the same protected// API the same way:////   composePluginApi(plugins)//     -> observabilityMiddleware(api)            (defect safety net)//     -> HttpApiBuilder.layer(api)               (the routes)//          + CoreHandlers + composePluginHandlerLayer(plugins)//          + ErrorCapture (Sentry / console / in-memory)//          + RouterConfigLive                    (maxParamLength bump)//// They differ only in three knobs://   - `errorCapture` — the host's `ErrorCapture` impl (Sentry vs console).//   - `router`       — an optional prefixed `HttpRouter` view (self-host//                      serves under `/api`; cloud/local serve at root).//   - the plugin set — typed straight off the passed tuple.//// The account API mounts the same provider-neutral `AccountHandlers` behind a// per-request `AccountProvider`, again differing only by the optional router and// the service-providing layer.//// `toApiHandler` is the `HttpRouter.toWebHandler(appLayer + platform)` boiler-// plate that every web-handler binding repeats: build, expose `{ handler,// dispose }`. The per-host listening adapters (TanStack Start request// middleware, the Bun socket) stay app-specific.//// NOTE: this module intentionally imports nothing host-specific (no// `cloudflare:workers`, no Bun platform), so it stays importable from the// Workers test runtime and from every host.// --------------------------------------------------------------------------- import { HttpApiBuilder } from "effect/unstable/httpapi";import { HttpRouter, HttpServer } from "effect/unstable/http";import { Layer } from "effect";import type { AnyPlugin } from "@executor-js/sdk"; import { observabilityMiddleware, type ErrorCapture } from "../observability";import { AccountHttpApi } from "../account/api";import { AccountHandlers } from "../account/handlers";import type { AccountProvider } from "../account/service";import { composePluginApi, composePluginHandlerLayer } from "../plugin-routes";import { CoreHandlers } from "../handlers";import { requestScopedMiddleware } from "./request-scoped";import { RouterConfigLive } from "./router-config"; // `HttpApiBuilder.layer` requires `HttpRouter.HttpRouter`; a host that serves// the API under a path prefix passes a `router.prefixed("/api")` view as this// layer so every route carries the prefix. Hosts serving at root omit it (the// ambient default `HttpRouter` is used). The prefixed view DERIVES from the// ambient router, so it both provides and requires `HttpRouter.HttpRouter`// (self-host's `PrefixedRouterLive`). Keeping the requirement channel precise// (not `any`) avoids leaking `any` into every assembled host layer.type RouterLayer = Layer.Layer<HttpRouter.HttpRouter, never, HttpRouter.HttpRouter>; // ---------------------------------------------------------------------------// Protected (plugin) API// --------------------------------------------------------------------------- export interface MakeProtectedApiLayerOptions {  /**   * The host's `ErrorCapture` implementation. Provided ABOVE the handler +   * middleware layers so both the `capture(...)` typed-channel translation   * (`StorageError -> InternalError(traceId)`) AND the observability   * middleware's defect catchall resolve the same backend.   */  readonly errorCapture: Layer.Layer<ErrorCapture>;  /**   * Optional prefixed `HttpRouter` view (e.g. `router.prefixed("/api")`). When   * present every API route serves under that prefix. Omit to serve at root.   */  readonly router?: RouterLayer;} /** * Assemble the protected (plugin) API into its boot Layer. * * Wires, in order: `composePluginApi(plugins)` -> * `observabilityMiddleware(api)` -> `HttpApiBuilder.layer(api)` provided with * `CoreHandlers` + `composePluginHandlerLayer(plugins)` + the host's * `ErrorCapture` + `RouterConfigLive` (+ the optional prefixed router). * * Returns `{ api, handlers, layer }` because hosts consume all three * independently: *   - `api`      — the composed `HttpApi` value, reused for Swagger/OpenAPI, *                  `.prefix(...)` spec views, `HttpApiClient.ForApi`, and *                  `.add(...)` of host-only groups (cloud docs). *   - `handlers` — `CoreHandlers` + every plugin's late-binding `handlers()` *                  Layer; reused by test harnesses building against a fake *                  middleware. *   - `layer`    — the wired boot Layer. The plugin handler Layers stay *                  late-binding (they require each plugin's `*ExtensionService` *                  Tag), so the host provides its per-request execution-stack *                  middleware on this `layer` itself. */export const makeProtectedApiLayer = <TPlugins extends readonly AnyPlugin[]>(  plugins: TPlugins,  options: MakeProtectedApiLayerOptions,) => {  const api = composePluginApi(plugins);  const handlers = Layer.mergeAll(CoreHandlers, composePluginHandlerLayer(plugins));   // `RouterConfigLive` is folded in here so every host gets the raised  // `maxParamLength` without re-wiring it; the optional prefixed router is  // merged alongside it so `HttpApiBuilder.layer`'s `HttpRouter` requirement is  // satisfied by the prefixed view when the host wants a path namespace.  const routerSupport = options.router    ? Layer.merge(RouterConfigLive, options.router)    : RouterConfigLive;   const layer = HttpApiBuilder.layer(api).pipe(    Layer.provide(Layer.mergeAll(handlers, observabilityMiddleware(api))),    Layer.provide(options.errorCapture),    Layer.provide(routerSupport),  );   return { api, handlers, layer };}; // ---------------------------------------------------------------------------// Account API// --------------------------------------------------------------------------- export interface MakeAccountApiLayerOptions {  /**   * Optional prefixed `HttpRouter` view, matching the protected API's prefix so   * the account routes register on the same `/api`-prefixed router.   */  readonly router?: RouterLayer;} /** * Mount the shared, provider-neutral `AccountHandlers` (me / API keys / org) * behind a per-request `AccountProvider`: * *   HttpApiBuilder.layer(AccountHttpApi) *     -> AccountHandlers *     -> the `AccountProvider`-providing middleware *     -> (optional) prefixed router * * `accountProviderMiddleware` is the router-middleware Layer that provides * `AccountProvider` per request — `requestScopedMiddleware(accountProviderLayer) * .layer` for the self-contained case (self-host's Better Auth service), or a * bespoke middleware combined with `requestScopedMiddleware` (cloud builds the * WorkOS service INSIDE the request body so it closes over the per-request * postgres socket). Going through a router middleware means the handler's * `AccountProvider` requirement is satisfied per-request WITHOUT leaking into the * app layer's output requirements (a plain `Layer.provide` on the builder layer * would leak it and break the host build). * * The middleware's three channels are generic (`MOut`/`ME`/`MR`) so the * provided `Request.From<"Requires", AccountProvider>` marker AND each host's * remaining requirements (cloud's long-lived control-plane + billing services, * self-host's `never`) flow through precisely — a non-generic * `Layer<any, any, any>` parameter would widen the requirement channel to `any` * and break the host build's leftover-requirement tracking. * * Use `accountProviderMiddlewareLayer(accountProviderLayer)` for the common case. */export const makeAccountApiLayer = <MOut, ME, MR>(  accountProviderMiddleware: Layer.Layer<MOut, ME, MR>,  options: MakeAccountApiLayerOptions = {},) => {  const base = HttpApiBuilder.layer(AccountHttpApi).pipe(    Layer.provide(AccountHandlers),    Layer.provide(accountProviderMiddleware),  );  return options.router ? base.pipe(Layer.provide(options.router)) : base;}; /** * The common-case `AccountProvider` middleware: wrap a self-contained * `Layer<AccountProvider>` in `requestScopedMiddleware` and take its `.layer`. * (Hosts whose service must be built inside the request body — cloud — combine * their own middleware with `requestScopedMiddleware` and pass that instead.) */export const accountProviderMiddlewareLayer = (  accountProviderLayer: Layer.Layer<AccountProvider>,) => requestScopedMiddleware(accountProviderLayer).layer; // ---------------------------------------------------------------------------// App-layer web-handler binding// --------------------------------------------------------------------------- export interface ApiHandler {  readonly handler: (request: Request) => Promise<Response>;  readonly dispose: () => Promise<void>;} /** * Bind a fully-assembled app `Layer` to a `fetch`-style web handler. * * This is the `HttpRouter.toWebHandler(appLayer + HttpServer.layerServices)` * boilerplate every web-handler binding repeats: the web-handler binding * supplies the HTTP platform services itself (no listening socket), then * exposes `{ handler, dispose }`. Hosts that bind to a listening socket * (self-host's Bun server) keep their own platform layer and DON'T use this. * * `appLayer` must already provide every `HttpRouter`/route requirement; this * only adds `HttpServer.layerServices` so `toWebHandler` can run handlers off a * synthetic platform. */export const toApiHandler = (  // The app layer must already provide every route requirement; only the HTTP  // platform is missing, which `HttpServer.layerServices` supplies below. Typed  // loosely (success/error/requirement channels erased) because each host's app  // layer has a different, fully-resolved set — self-host's `AppLayer` outputs  // `never`, local's outputs `ExecutorService | …` (provideMerge keeps them in  // the success channel). The runtime contract is the same either way.  // eslint-disable-next-line @typescript-eslint/no-explicit-any  appLayer: Layer.Layer<any, any, any>,): ApiHandler => {  // `HttpServer.layerServices` supplies the synthetic HTTP platform so  // `toWebHandler` can run handlers without a listening socket.  const web = HttpRouter.toWebHandler(appLayer.pipe(Layer.provideMerge(HttpServer.layerServices)));  // With every requirement provided the leftover `HR` is `never`, so `handler`  // is the one-arg `(request) => Promise<Response>` form — but the loose  // `R = any` input widens `HR` to `any` (a two-arg signature), so narrow back  // to the runtime contract.  const handler = web.handler as (request: Request) => Promise<Response>;  return { handler, dispose: web.dispose };};