@lakutata/entrypoint 3.0.0-beta.0

package/dist/types/adapter/express/Responders.d.ts

@@ -0,0 +1,89 @@
+import type { Request, Response } from 'express';
+import { describeError, type HTTPErrorOrigin, statusOfError } from '../../lib/HTTPErrors.js';
+export { describeError, statusOfError, type HTTPErrorOrigin };
+/**
+ * How {@link expressHTTPEntrypoint} writes the results and the errors of the actions (its `respond` option). Implement
+ * it to give the responses another shape; {@link JSONResponder} is the default, {@link jsonEnvelope} wraps them in an
+ * envelope. The file results and the event streams are not written by the responder.
+ */
+export interface ExpressResponder {
+    /**
+     * Write the result of an action. For a `StatusResult`, its status and headers are already set on the response and
+     * `data` is its payload.
+     * @param response The express response to write.
+     * @param data The action's result, `undefined` when it returned nothing.
+     * @param request The express request being answered.
+     */
+    success(response: Response, data: unknown, request: Request): void;
+    /**
+     * Write an error: a failed action (validation, access control, its own exception), an error passed by an express
+     * middleware (`next(error)`: an authenticator), or a request matching no route (`RouteNotFoundException`). Not
+     * called once the response headers are sent, nor after the client left.
+     * @param response The express response to write.
+     * @param error The thrown error.
+     * @param request The express request being answered.
+     * @param origin Where the error comes from: `'action'` (the dispatch of an action failed) or `'request'` (an
+     * express middleware, a route not found); see {@link HTTPErrorOrigin}.
+     */
+    error(response: Response, error: unknown, request: Request, origin?: HTTPErrorOrigin): void;
+}
+/**
+ * The default responder of {@link expressHTTPEntrypoint}: a result is sent as JSON, no result as an empty 204 (or the
+ * status set by a `StatusResult`); an error is sent as `{errno, errMsg}` (see `describeError`) with its HTTP status
+ * (see `statusOfError`: the first 4xx status in its cause chain, its own status, or 500).
+ */
+export declare const JSONResponder: ExpressResponder;
+/**
+ * The options of {@link jsonEnvelope}.
+ */
+export type JSONEnvelopeOptions = {
+    /**
+     * The HTTP status of every error response, such as 200 for the clients that read the errors from the envelope.
+     * @default the error's own status (see `statusOfError`)
+     */
+    errorStatus?: number;
+    /**
+     * The HTTP status of the errors of the actions only (their dispatch failed: validation, access control, their own
+     * exceptions), over `errorStatus`; the errors of the express middlewares (an authenticator's 401) and the routes
+     * not found keep theirs. 200 answers as the applications of lakutata 2.x usually did.
+     * @default `errorStatus`
+     */
+    actionErrorStatus?: number;
+};
+/**
+ * Create a responder for {@link expressHTTPEntrypoint} that wraps every response in the envelope
+ * `{errno, errMsg, data}`: a result as `{errno: null, errMsg: null, data}` (`data` is `null` when the action returned
+ * nothing, and its status is not turned into 204), an error as `{errno, errMsg, data: null}` with the error's status,
+ * the `errorStatus` option, or for the errors of the actions the `actionErrorStatus` option.
+ * @param options The envelope options.
+ * @returns The responder, to give to the `respond` option of `expressHTTPEntrypoint`.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildEntrypoints, Controller} from 'lakutata/com/entrypoint'
+ * import {GET} from 'lakutata/decorator/ctrl'
+ * import {expressHTTPEntrypoint, jsonEnvelope} from 'lakutata/adapter/express'
+ *
+ * class PingController extends Controller {
+ *     //GET /ping answers {"errno": null, "errMsg": null, "data": "pong"}
+ *     @GET('/ping')
+ *     public async ping(): Promise<string> {
+ *         return 'pong'
+ *     }
+ * }
+ *
+ * Application.run({
+ *     id: 'web.app',
+ *     name: 'Web',
+ *     components: {
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [PingController],
+ *             //The errors of the actions answered with 200 too (as the applications of lakutata 2.x), the routes not
+ *             //found and the errors of the express middlewares with their status (404, 401…)
+ *             http: expressHTTPEntrypoint({port: 8080, respond: jsonEnvelope({actionErrorStatus: 200})})
+ *         })
+ *     }
+ * })
+ * ```
+ */
+export declare function jsonEnvelope(options?: JSONEnvelopeOptions): ExpressResponder;

package/dist/types/adapter/express/StaticUI.d.ts

@@ -0,0 +1,83 @@
+import { type RequestHandler } from 'express';
+/**
+ * The options of {@link staticUI}.
+ */
+export type StaticUIOptions = {
+    /**
+     * Serve a single-page application: a GET or HEAD request accepting HTML, whose path has no file extension and
+     * matches no file, is answered with the index (the client-side router handles the path). With `false`, such a
+     * request is passed on (a 404 behind `expressHTTPEntrypoint`).
+     * @default true
+     */
+    spa?: boolean;
+    /**
+     * The index file of the application, relative to the directory.
+     * @default 'index.html'
+     */
+    index?: string;
+    /**
+     * How long the browsers may cache the files with a content hash in their name (the assets of a Vite build:
+     * `index-B2x9fQ1a.js`): a number of seconds, or a duration (`'30d'`, `'12h'`; a string of digits is seconds). A file
+     * counts as hashed when it is a script, a style, a font or an image whose name ends with a dot or a dash followed by
+     * at least 8 letters, digits, `_` or `-`, among them a digit or an uppercase letter, before its extension
+     * (`index-B2x9fQ1a.js`, `main.3f2a1b9c.css`, not `my-component.js`). The other files and the index are sent with
+     * `Cache-Control: no-cache`.
+     * @default 31536000 (one year)
+     */
+    assetsMaxAge?: string | number;
+};
+/**
+ * Whether a file of a built UI has a content hash in its name: a script, a style, a font or an image whose name ends
+ * with a dot or a dash followed by at least 8 letters, digits, `_` or `-`, among them a digit or an uppercase letter
+ * @param file
+ * @internal
+ */
+export declare function isHashedAsset(file: string): boolean;
+/**
+ * The seconds the hashed assets are cached: a number of seconds, or a duration
+ * @param value
+ * @internal
+ */
+export declare function assetsMaxAge(value: string | number | undefined): number;
+/**
+ * Create an express handler serving a built web UI (the `dist` directory of a Vite application): its files, and its
+ * index for the paths of its client-side routes. Given as the `fallback` of {@link expressHTTPEntrypoint}, it never
+ * receives the paths of the actions. It needs the optional peer dependency `express`.
+ *
+ * The files with a content hash in their name are cached for a long time (`assetsMaxAge`), the other files and the
+ * index are revalidated on each request. A request matching no file that is not a page request (an asset, a non-GET
+ * request, a client not accepting HTML) is passed on to the next handler.
+ * @param directory The directory of the built UI, resolved from the current working directory.
+ * @param options How the index is served and the assets cached.
+ * @returns The express request handler.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildEntrypoints, Controller} from 'lakutata/com/entrypoint'
+ * import {GET} from 'lakutata/decorator/ctrl'
+ * import {expressHTTPEntrypoint, staticUI} from 'lakutata/adapter/express'
+ *
+ * class DeviceController extends Controller {
+ *     //GET /api/devices answers the action; GET /settings answers the index of the UI
+ *     @GET('/api/devices')
+ *     public async list(): Promise<string[]> {
+ *         return ['sensor-1']
+ *     }
+ * }
+ *
+ * Application.run({
+ *     id: 'console.app',
+ *     name: 'Console',
+ *     components: {
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [DeviceController],
+ *             http: expressHTTPEntrypoint({
+ *                 port: 8080,
+ *                 fallback: staticUI('./ui/dist', {assetsMaxAge: 86400})
+ *             })
+ *         })
+ *     }
+ * })
+ * ```
+ */
+export declare function staticUI(directory: string, options?: StaticUIOptions): RequestHandler;

package/dist/types/adapter/fastify/FastifyHTTPEntrypoint.d.ts

@@ -0,0 +1,156 @@
+import { type FastifyInstance, type FastifyReply, type FastifyRequest, type FastifyServerOptions } from 'fastify';
+import type { Server } from 'node:http';
+import type { Module } from '@lakutata/core';
+import type { EntrypointAdapter } from '../../channel/EntrypointAdapter.js';
+import type { MiddlewareDefinition } from '../../lib/Middleware.js';
+import { HTTPContext } from '../../context/HTTPContext.js';
+import { type FastifyResponder } from './Responders.js';
+/**
+ * What the `before` hook of {@link fastifyHTTPEntrypoint} receives besides the fastify instance: the entrypoint's
+ * module, the HTTP server (not listening yet) and the routes the actions will occupy.
+ */
+export type FastifyHookContext = {
+    /**
+     * The module owning the entrypoint, to get the application's objects from (`await module.getObject('db')`).
+     */
+    readonly module: Module;
+    /**
+     * The HTTP server of the fastify instance. It does not listen yet when the hook runs; attach other servers to it
+     * there (such as a socket.io server, see the `server` option of `socketIOServiceEntrypoint`).
+     */
+    readonly server: Server;
+    /**
+     * Each action route mapped to its HTTP methods, in upper case (`'/users/:id'` → `{'GET', 'DELETE'}`).
+     */
+    readonly routes: Map<string, Set<string>>;
+    /**
+     * The first segment of each action route (`'/device'`, `'/user'`…). A route starting with a parameter (`/:id`)
+     * adds none.
+     */
+    readonly actionPrefixes: string[];
+    /**
+     * Tell whether a request path belongs to the actions: it equals one of the action prefixes or starts with one
+     * followed by `/`.
+     */
+    readonly isActionPath: (requestPath: string) => boolean;
+};
+/**
+ * The options of {@link fastifyHTTPEntrypoint}.
+ */
+export type FastifyHTTPEntrypointOptions = {
+    /**
+     * The adapter name, to tell apart several HTTP adapters of one entrypoint.
+     */
+    name?: string;
+    /**
+     * The port the server listens on; 0 picks a random free port. The entrypoint fails to start when the port is in use.
+     * @default 80
+     */
+    port?: number;
+    /**
+     * The host or address the server listens on.
+     * @default every interface, as the other HTTP adapters (`::`, or `0.0.0.0` without IPv6)
+     */
+    host?: string;
+    /**
+     * An existing fastify instance to add the action routes to, or the options of the instance to create (`bodyLimit`,
+     * `trustProxy`, `logger`…). The adapter closes the instance when it stops, a given one included.
+     * @default a new fastify instance with its default options (a body limit of 1 MiB)
+     */
+    fastify?: FastifyInstance | FastifyServerOptions;
+    /**
+     * Build an action's input from a request. The route parameters are always merged over its result.
+     * @default the query parameters, then the properties of an object body over them (an array body is ignored)
+     */
+    input?: (request: FastifyRequest) => Record<string, unknown>;
+    /**
+     * How the results and the errors of the actions are written.
+     * @default FastifyJSONResponder
+     */
+    respond?: FastifyResponder;
+    /**
+     * The middlewares of this adapter's actions, run after the entrypoint's global middlewares.
+     */
+    middlewares?: MiddlewareDefinition[];
+    /**
+     * Run before the action routes are added, to register the application's own plugins, hooks and routes. A failure
+     * fails the entrypoint start.
+     */
+    before?: (app: FastifyInstance, context: FastifyHookContext) => void | Promise<void>;
+    /**
+     * The handler of the requests that match no route and whose path is outside the action prefixes, such as the pages
+     * of a web application. The unmatched requests inside the action prefixes, and all of them without a fallback, are
+     * answered with a `RouteNotFoundException` (404).
+     */
+    fallback?: (request: FastifyRequest, reply: FastifyReply) => unknown;
+    /**
+     * Run when the adapter stops, after the server is closed.
+     */
+    stop?: () => void | Promise<void>;
+    /**
+     * The interval between the comments keeping the event streams (`EventsResult`) alive through the proxies, in
+     * milliseconds.
+     * @default 15000
+     */
+    heartbeat?: number;
+};
+/**
+ * Create the HTTP adapter of an entrypoint served by a fastify instance: each HTTP action (`@GET`, `@POST`,
+ * `@HTTPAction`…) becomes a fastify route. It needs the optional peer dependency `fastify`.
+ *
+ * An action's input is the request's query and body (see the `input` option) with the route parameters merged over
+ * them. Its result is written by the responder (JSON by default, 204 for no result); a `StatusResult` sets the status
+ * and the headers, a `FileResult` sends a file, a buffer or a stream (its content type guessed from the extension of
+ * its file name, 304 when its ETag matches `If-None-Match`), and an `EventsResult` streams Server-Sent Events. An action
+ * that writes the response itself (through `HTTPContext.response`) is left alone. The errors, those of fastify included
+ * (a body too large: 413, a malformed JSON body: 400), are written by the responder with their status (500 by default).
+ * A GET action also answers HEAD, unless a HEAD action is declared for its route.
+ *
+ * When the client disconnects before the response, the action's abort signal fires and nothing is written. When the
+ * entrypoint stops, fastify stops accepting connections and answers the new requests with 503, the event streams end,
+ * and the requests in progress are given up to one second after they settle to send their responses before the
+ * remaining connections are closed.
+ * @param options The adapter options; by default it listens on port 80 with a new fastify instance.
+ * @returns The adapter, to give to the `http` option of `buildEntrypoints`.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildEntrypoints, Controller} from 'lakutata/com/entrypoint'
+ * import {GET, POST} from 'lakutata/decorator/ctrl'
+ * import {fastifyHTTPEntrypoint} from 'lakutata/adapter/fastify'
+ *
+ * class UserController extends Controller {
+ *     //GET /users/1?verbose=true: the route parameter id merged over the query
+ *     @GET('/users/:id')
+ *     public async get(input: {id: string, verbose?: string}): Promise<{id: string}> {
+ *         return {id: input.id}
+ *     }
+ *
+ *     //POST /users with the JSON body {"name": "Ada"}
+ *     @POST('/users')
+ *     public async create(input: {name: string}): Promise<{name: string}> {
+ *         return {name: input.name}
+ *     }
+ * }
+ *
+ * Application.run({
+ *     id: 'web.app',
+ *     name: 'Web',
+ *     components: {
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [UserController],
+ *             http: fastifyHTTPEntrypoint({
+ *                 port: 8080,
+ *                 host: '0.0.0.0',
+ *                 fastify: {bodyLimit: 5 * 1024 * 1024, trustProxy: true},
+ *                 //The application's own routes
+ *                 before: (app): void => {
+ *                     app.get('/health', async (): Promise<string> => 'ok')
+ *                 }
+ *             })
+ *         })
+ *     }
+ * })
+ * ```
+ */
+export declare function fastifyHTTPEntrypoint(options?: FastifyHTTPEntrypointOptions): EntrypointAdapter<HTTPContext>;

package/dist/types/adapter/fastify/Responders.d.ts

@@ -0,0 +1,88 @@
+import type { FastifyReply, FastifyRequest } from 'fastify';
+import { type HTTPErrorOrigin } from '../../lib/HTTPErrors.js';
+/**
+ * How {@link fastifyHTTPEntrypoint} writes the results and the errors of the actions (its `respond` option). Implement
+ * it to give the responses another shape; {@link FastifyJSONResponder} is the default, {@link fastifyJSONEnvelope}
+ * wraps them in an envelope. The file results and the event streams are not written by the responder.
+ */
+export interface FastifyResponder {
+    /**
+     * Write the result of an action. For a `StatusResult`, its status and headers are already set on the reply and
+     * `data` is its payload.
+     * @param reply The fastify reply to send.
+     * @param data The action's result, `undefined` when it returned nothing.
+     * @param request The fastify request being answered.
+     */
+    success(reply: FastifyReply, data: unknown, request: FastifyRequest): void;
+    /**
+     * Write an error: a failed action (validation, access control, its own exception), an error of fastify (a hook such
+     * as an authenticator, a body too large), or a request matching no route (`RouteNotFoundException`). Not called for
+     * an action once the reply is sent, nor after the client left.
+     * @param reply The fastify reply to send.
+     * @param error The thrown error.
+     * @param request The fastify request being answered.
+     * @param origin Where the error comes from: `'action'` (the dispatch of an action failed) or `'request'` (a hook,
+     * an error of fastify, a route not found); see `HTTPErrorOrigin`.
+     */
+    error(reply: FastifyReply, error: unknown, request: FastifyRequest, origin?: HTTPErrorOrigin): void;
+}
+/**
+ * The default responder of {@link fastifyHTTPEntrypoint}: a result is sent as JSON, no result as an empty 204 (or the
+ * status set by a `StatusResult`); an error is sent as `{errno, errMsg}` (see `describeError`) with its HTTP status
+ * (see `statusOfError`: the first 4xx status in its cause chain, its own status, or 500).
+ */
+export declare const FastifyJSONResponder: FastifyResponder;
+/**
+ * The options of {@link fastifyJSONEnvelope}.
+ */
+export type FastifyJSONEnvelopeOptions = {
+    /**
+     * The HTTP status of every error response, such as 200 for the clients that read the errors from the envelope.
+     * @default the error's own status (see `statusOfError`)
+     */
+    errorStatus?: number;
+    /**
+     * The HTTP status of the errors of the actions only (their dispatch failed: validation, access control, their own
+     * exceptions), over `errorStatus`; the errors of the hooks (an authenticator's 401), of fastify and the routes not
+     * found keep theirs. 200 answers as the applications of lakutata 2.x usually did.
+     * @default `errorStatus`
+     */
+    actionErrorStatus?: number;
+};
+/**
+ * Create a responder for {@link fastifyHTTPEntrypoint} that wraps every response in the envelope
+ * `{errno, errMsg, data}`: a result as `{errno: null, errMsg: null, data}` (`data` is `null` when the action returned
+ * nothing, and its status is not turned into 204), an error as `{errno, errMsg, data: null}` with the error's status,
+ * the `errorStatus` option, or for the errors of the actions the `actionErrorStatus` option.
+ * @param options The envelope options.
+ * @returns The responder, to give to the `respond` option of `fastifyHTTPEntrypoint`.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildEntrypoints, Controller} from 'lakutata/com/entrypoint'
+ * import {GET} from 'lakutata/decorator/ctrl'
+ * import {fastifyHTTPEntrypoint, fastifyJSONEnvelope} from 'lakutata/adapter/fastify'
+ *
+ * class PingController extends Controller {
+ *     //GET /ping answers {"errno": null, "errMsg": null, "data": "pong"}
+ *     @GET('/ping')
+ *     public async ping(): Promise<string> {
+ *         return 'pong'
+ *     }
+ * }
+ *
+ * Application.run({
+ *     id: 'web.app',
+ *     name: 'Web',
+ *     components: {
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [PingController],
+ *             //The errors of the actions answered with 200 too (as the applications of lakutata 2.x), the routes not
+ *             //found and the errors of the hooks with their status (404, 401…)
+ *             http: fastifyHTTPEntrypoint({port: 8080, respond: fastifyJSONEnvelope({actionErrorStatus: 200})})
+ *         })
+ *     }
+ * })
+ * ```
+ */
+export declare function fastifyJSONEnvelope(options?: FastifyJSONEnvelopeOptions): FastifyResponder;

package/dist/types/adapter/http/HTTPServiceEntrypoint.d.ts

@@ -0,0 +1,117 @@
+import { type IncomingMessage, type Server } from 'node:http';
+import type { EntrypointAdapter } from '../../channel/EntrypointAdapter.js';
+import type { MiddlewareDefinition } from '../../lib/Middleware.js';
+import { ServiceContext } from '../../context/ServiceContext.js';
+/**
+ * The options of {@link httpServiceEntrypoint}.
+ */
+export type HTTPServiceEntrypointOptions = {
+    /**
+     * The adapter name, to tell apart several service adapters of one entrypoint.
+     */
+    name?: string;
+    /**
+     * The port the server listens on; 0 picks a random free port. The entrypoint fails to start when the port is in use.
+     * @default 3000
+     */
+    port?: number;
+    /**
+     * The host or address the server listens on.
+     * @default all the interfaces
+     */
+    host?: string;
+    /**
+     * The path receiving the requests (POST). The event stream is served on `events` under it (`/api` → `/api/events`).
+     * @default '/'
+     */
+    path?: string;
+    /**
+     * The largest request body, in bytes; a larger one is answered with 413 and an error response.
+     * @default 10485760 (10 MiB)
+     */
+    limit?: number;
+    /**
+     * The middlewares of this adapter's actions, run after the entrypoint's global middlewares.
+     */
+    middlewares?: MiddlewareDefinition[];
+    /**
+     * Run once the server listens, with the server (to read the port picked for port 0). A failure fails the entrypoint
+     * start.
+     */
+    listening?: (server: Server) => void | Promise<void>;
+};
+/**
+ * Get the HTTP request carrying a service action's request, when {@link httpServiceEntrypoint} serves it (to read its
+ * headers, its remote address…).
+ * @param context The service action's context (`this.context` in a controller).
+ * @returns The Node.js HTTP request, or `undefined` when another adapter serves the request.
+ * @example
+ * ```typescript
+ * import {Controller, httpRequestOfContext, ServiceContext} from 'lakutata/com/entrypoint'
+ * import {ServiceAction} from 'lakutata/decorator/ctrl'
+ *
+ * class WhoAmIController extends Controller {
+ *     @ServiceAction({cmd: 'whoami'})
+ *     public async whoami(): Promise<string | undefined> {
+ *         return httpRequestOfContext(this.context as ServiceContext)?.socket.remoteAddress
+ *     }
+ * }
+ * ```
+ */
+export declare function httpRequestOfContext(context: ServiceContext): IncomingMessage | undefined;
+/**
+ * Create a service adapter of an entrypoint served over plain HTTP, handy to call the service actions from tools such
+ * as curl or Postman during development. It needs no optional dependency.
+ *
+ * A request is a `POST` to the path whose JSON body holds the action's pattern and input (`{"cmd": "echo", "text":
+ * "hi"}`). The response is always 200 with the body `{success, error, payload}` (see `ServiceResponseCodec`): `payload`
+ * is the result, or `error` the whole error object when the action failed (no matching action, validation…). A body that
+ * is not JSON or exceeds `limit` is answered with 400 and an error body; any other method or path with 404. The CORS
+ * headers allow any origin.
+ *
+ * The events pushed to the clients (`Entrypoint.notify`, `Entrypoint.broadcast`) are streamed as Server-Sent Events by
+ * `GET <path>/events`: each event's name is the SSE event, its arguments the JSON array of its data. A client gives its
+ * id in the `id` header or the `id` query parameter (at most 200 characters), the same on its requests so that they
+ * carry it as `ServiceContext.clientId`; without one, the stream assigns a random id, sent first as the `client` event.
+ * The streams receive a keep-alive comment every 15 seconds.
+ *
+ * When a client disconnects before its response, the action's abort signal fires. When the entrypoint stops, the new
+ * requests are answered with an `EntrypointStoppedException` error; once the requests in progress end, the event
+ * streams are closed and the server shuts down.
+ * @param options The adapter options; by default it listens on port 3000 of all the interfaces, on the path `/`.
+ * @returns The adapter, to give to the `service` option of `buildEntrypoints`.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildEntrypoints, Controller, httpServiceEntrypoint} from 'lakutata/com/entrypoint'
+ * import {ServiceAction} from 'lakutata/decorator/ctrl'
+ *
+ * class EchoController extends Controller {
+ *     @ServiceAction({cmd: 'echo'})
+ *     public async echo(input: {text: string}): Promise<string> {
+ *         return input.text
+ *     }
+ * }
+ *
+ * Application.run({
+ *     id: 'echo.service',
+ *     name: 'Echo',
+ *     components: {
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [EchoController],
+ *             service: httpServiceEntrypoint({port: 3000, path: '/rpc'})
+ *         })
+ *     }
+ * })
+ *
+ * //A client: the response is {"success": true, "error": null, "payload": "hi"}
+ * const response: Response = await fetch('http://localhost:3000/rpc', {
+ *     method: 'POST',
+ *     headers: {'Content-Type': 'application/json', 'id': 'client-1'},
+ *     body: JSON.stringify({cmd: 'echo', text: 'hi'})
+ * })
+ * console.log(await response.json())
+ * //The events pushed to client-1: GET http://localhost:3000/rpc/events?id=client-1 (text/event-stream)
+ * ```
+ */
+export declare function httpServiceEntrypoint(options?: HTTPServiceEntrypointOptions): EntrypointAdapter<ServiceContext>;