@lakutata/entrypoint 3.0.0 → 3.1.0

package/dist/esm/adapter/http/HTTPServiceProxy.js

@@ -0,0 +1,366 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { randomUUID } from 'node:crypto';
+import { Component, DTO } from '@lakutata/core';
+import { Configurable } from '@lakutata/core/decorator/di';
+import { ServiceResponseCodec } from '../../lib/ServiceResponseCodec.js';
+import { ServiceUnavailableException } from '../../exceptions/ServiceUnavailableException.js';
+/**
+ * Build the component options of an {@link HTTPServiceProxy}, to register it in the `components` of an application.
+ * @param options The service's address, and the headers, client id and reconnection delay.
+ * @returns The component options.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildHTTPServiceProxy, type HTTPServiceProxy} from 'lakutata/com/entrypoint'
+ *
+ * Application
+ *     .run(() => ({
+ *         id: 'shop.app',
+ *         name: 'Shop',
+ *         components: {
+ *             inventory: buildHTTPServiceProxy({url: 'http://inventory.internal:3000/'}),
+ *             //With a token, and a stable client id to receive the events of the service
+ *             orders: buildHTTPServiceProxy({
+ *                 url: 'https://orders.internal/rpc',
+ *                 headers: {Authorization: `Bearer ${process.env.ORDERS_TOKEN}`},
+ *                 clientId: 'shop-1'
+ *             })
+ *         }
+ *     }))
+ *     .onLaunched(async (app: Application): Promise<void> => {
+ *         const inventory: HTTPServiceProxy = await app.getObject<HTTPServiceProxy>('inventory')
+ *         console.log(await inventory.invoke({cmd: 'stock.get', product: 'lamp'}))
+ *     })
+ * ```
+ */
+export const buildHTTPServiceProxy = (options) => {
+    return {
+        class: HTTPServiceProxy,
+        url: options.url,
+        headers: options.headers,
+        clientId: options.clientId,
+        reconnectDelay: options.reconnectDelay
+    };
+};
+/**
+ * Whether a body is a service response
+ * @param body
+ */
+function isServiceResponse(body) {
+    return !!body && typeof body === 'object' && typeof body.success === 'boolean';
+}
+/**
+ * The reason a request failed: the network error under the "fetch failed" of fetch(), each of them when several
+ * addresses were tried (localhost: ::1, then 127.0.0.1)
+ * @param error
+ */
+function reasonOf(error) {
+    const cause = error?.cause ?? error;
+    if (cause instanceof AggregateError && cause.errors.length)
+        return cause.errors.map((each) => each?.message ?? String(each)).join(', ');
+    return cause?.message || error?.message || String(error);
+}
+/**
+ * The events of a stream of Server-Sent Events: their names and their data, the comments skipped
+ * @param stream
+ */
+async function* serverSentEvents(stream) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let event = 'message';
+    let data = [];
+    try {
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done)
+                return;
+            buffer += decoder.decode(value, { stream: true });
+            //The complete lines; the last one may be cut by the chunk
+            const lines = buffer.split('\n');
+            buffer = lines.pop();
+            for (const read of lines) {
+                const line = read.endsWith('\r') ? read.slice(0, -1) : read;
+                //A blank line ends the event
+                if (!line) {
+                    if (data.length)
+                        yield { event: event, data: data.join('\n') };
+                    event = 'message';
+                    data = [];
+                    continue;
+                }
+                if (line.startsWith(':'))
+                    continue;
+                const colon = line.indexOf(':');
+                const field = colon < 0 ? line : line.slice(0, colon);
+                const value = colon < 0 ? '' : line.slice(colon + 1).replace(/^ /, '');
+                if (field === 'event')
+                    event = value;
+                else if (field === 'data')
+                    data.push(value);
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+/**
+ * The client of a lakutata service served over HTTP by `httpServiceEntrypoint`: it invokes the service's actions by
+ * their patterns and listens to the events the service pushes to it. It is a component (a singleton), registered with
+ * {@link buildHTTPServiceProxy}; it needs no package (it uses the `fetch()` of Node.js), and its event stream is opened
+ * when the first listener is added.
+ *
+ * The failures of the remote actions are thrown as `ServiceInvokeException`, with the remote error's message and
+ * properties (`errno`, `statusCode`…) and the address as its `service`; a service that gives no response (unreachable,
+ * too slow, or an answer that is not a service response) as a `ServiceUnavailableException`.
+ * @example
+ * ```typescript
+ * import {Component} from 'lakutata'
+ * import {type HTTPServiceProxy, ServiceInvokeException, ServiceUnavailableException} from 'lakutata/com/entrypoint'
+ * import {Inject} from 'lakutata/decorator/di'
+ *
+ * class StockWatcher extends Component {
+ *     //Registered as inventory: buildHTTPServiceProxy({url: 'http://inventory.internal:3000/'})
+ *     @Inject('inventory')
+ *     protected readonly inventory: HTTPServiceProxy
+ *
+ *     protected async init(): Promise<void> {
+ *         //The events the inventory pushes with Entrypoint.notify(clientId, 'lowStock', product, quantity)
+ *         this.inventory.on('lowStock', (product: string, quantity: number): void => {
+ *             console.log(`${product}: ${quantity} left`)
+ *         })
+ *     }
+ *
+ *     public async quantity(product: string): Promise<number | undefined> {
+ *         try {
+ *             //5 seconds at most; the inventory aborts the action's signal when the call gives up
+ *             return await this.inventory.invoke({cmd: 'stock.get', product: product}, 5000)
+ *         } catch (error) {
+ *             //The action failed: its error
+ *             if (error instanceof ServiceInvokeException && error.errno === 'E_PRODUCT_NOT_FOUND') return undefined
+ *             //The inventory gave no response
+ *             if (error instanceof ServiceUnavailableException) return undefined
+ *             throw error
+ *         }
+ *     }
+ * }
+ * ```
+ */
+export class HTTPServiceProxy extends Component {
+    #id;
+    #eventsURL;
+    #listeners = new Map();
+    #events;
+    #destroyed = false;
+    /**
+     * Create the client id and the address of the event stream (`<url>/events?id=<id>`); nothing connects before the
+     * first call.
+     * @protected
+     */
+    async init() {
+        this.#id = this.clientId ?? randomUUID();
+        const events = new URL(this.url);
+        events.pathname = `${events.pathname.replace(/\/+$/, '')}/events`;
+        events.searchParams.set('id', this.#id);
+        this.#eventsURL = events.href;
+    }
+    /**
+     * Close the event stream and remove the listeners (the calls in progress complete).
+     * @protected
+     */
+    async destroy() {
+        this.#destroyed = true;
+        this.#events?.abort();
+        this.#listeners.clear();
+    }
+    /**
+     * The client's id: the configured `clientId`, or a random UUID. It is sent as the `id` header of the calls, and is
+     * the `ServiceContext.clientId` of the service's actions.
+     */
+    get id() {
+        return this.#id;
+    }
+    /**
+     * Invoke an action of the service, matched by its pattern.
+     * @param input The action's pattern and its input in one object (`{cmd: 'order.get', id: 1}`), sent as JSON: the
+     * values JSON cannot hold (functions, `undefined`, class instances) are lost or turned into plain objects.
+     * @param timeout The longest wait for the response, in milliseconds; 600000 (10 minutes) by default. The request is
+     * abandoned after it, and the service aborts the action's signal.
+     * @returns The action's result, decoded from JSON: `undefined` when the action returned nothing.
+     * @throws {ServiceInvokeException} When the action fails (no action matches the pattern, an invalid input, an error
+     * thrown, the service stopping), or the service refuses the request (another path, a body over its limit): the
+     * remote error's message and properties (`errno`…), the address as its `service`.
+     * @throws {ServiceUnavailableException} When the service gives no response: unreachable, no response within the
+     * timeout, or an answer that is not a service response. Its `cause` is the error of the request.
+     */
+    async invoke(input, timeout = 10 * 60 * 1000) {
+        let status;
+        let text;
+        try {
+            const response = await fetch(this.url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.headers, 'id': this.#id },
+                body: JSON.stringify(input),
+                signal: AbortSignal.timeout(timeout)
+            });
+            status = response.status;
+            text = await response.text();
+        }
+        catch (error) {
+            const exception = error?.name === 'TimeoutError'
+                ? new ServiceUnavailableException('The service {service} gave no response within {timeout} ms', { service: this.url, timeout: timeout })
+                : new ServiceUnavailableException('The service {service} cannot be reached: {reason}', { service: this.url, reason: reasonOf(error) });
+            exception.service = this.url;
+            exception.cause = error;
+            throw exception;
+        }
+        let body;
+        try {
+            body = JSON.parse(text);
+        }
+        catch {
+            //Not JSON: below
+        }
+        if (!isServiceResponse(body)) {
+            const exception = new ServiceUnavailableException('The service {service} answered {status} without a service response', { service: this.url, status: status });
+            exception.service = this.url;
+            throw exception;
+        }
+        return ServiceResponseCodec.decode(body, this.url);
+    }
+    /**
+     * Listen to an event the service pushes to this client (`Entrypoint.notify()`, `broadcast()`); the first listener
+     * opens the event stream. The listeners' errors are ignored. The `client` event, received when the stream opens,
+     * carries the client's id.
+     * @param eventName The event's name.
+     * @param listener Called with the event's arguments, decoded from JSON.
+     * @returns The proxy, to chain the calls.
+     */
+    on(eventName, listener) {
+        return this.add(eventName, listener, false);
+    }
+    /**
+     * Listen to an event the service pushes to this client, once: the listener is removed before it is called.
+     * @param eventName The event's name.
+     * @param listener Called with the event's arguments, decoded from JSON.
+     * @returns The proxy, to chain the calls.
+     */
+    once(eventName, listener) {
+        return this.add(eventName, listener, true);
+    }
+    /**
+     * Stop listening to an event; removing the last listener of all the events closes the event stream.
+     * @param eventName The event's name.
+     * @param listener The listener to remove; without it, all the event's listeners are removed.
+     * @returns The proxy, to chain the calls.
+     */
+    off(eventName, listener) {
+        const listeners = this.#listeners.get(eventName);
+        if (listeners && listener)
+            listeners.forEach((entry) => entry.listener === listener && listeners.delete(entry));
+        if (!listener || !listeners?.size)
+            this.#listeners.delete(eventName);
+        if (!this.#listeners.size) {
+            this.#events?.abort();
+            this.#events = undefined;
+        }
+        return this;
+    }
+    /**
+     * Add a listener, and open the event stream when it is not open.
+     * @param eventName The event's name.
+     * @param listener The listener.
+     * @param once Whether the listener is removed after its first call.
+     * @returns The proxy.
+     * @protected
+     */
+    add(eventName, listener, once) {
+        if (!this.#listeners.has(eventName))
+            this.#listeners.set(eventName, new Set());
+        this.#listeners.get(eventName).add({ listener: listener, once: once });
+        if (!this.#events)
+            void this.stream();
+        return this;
+    }
+    /**
+     * Read the event stream and call the listeners; the stream is opened again after `reconnectDelay` milliseconds
+     * when it ends or fails, while there are listeners. It stops once no listener is left (removed by
+     * {@link HTTPServiceProxy.off}, or the last `once()` listener called) or the proxy is destroyed.
+     * @returns A promise resolved once the reading stops.
+     * @protected
+     */
+    async stream() {
+        const abort = new AbortController();
+        this.#events = abort;
+        while (!abort.signal.aborted && !this.#destroyed && this.#listeners.size) {
+            try {
+                const response = await fetch(this.#eventsURL, { headers: { ...this.headers, 'Accept': 'text/event-stream' }, signal: abort.signal });
+                if (response.ok && response.body) {
+                    for await (const { event, data } of serverSentEvents(response.body)) {
+                        const listeners = this.#listeners.get(event);
+                        if (!listeners)
+                            continue;
+                        let args;
+                        try {
+                            args = JSON.parse(data);
+                        }
+                        catch {
+                            continue;
+                        }
+                        for (const entry of [...listeners]) {
+                            if (entry.once)
+                                listeners.delete(entry);
+                            try {
+                                entry.listener(...Array.isArray(args) ? args : [args]);
+                            }
+                            catch {
+                                //The errors of the listeners are theirs
+                            }
+                        }
+                        if (!listeners.size)
+                            this.#listeners.delete(event);
+                        //The last listener gone (a once listener called): the stream is closed
+                        if (!this.#listeners.size)
+                            abort.abort();
+                    }
+                }
+                else {
+                    await response.body?.cancel();
+                }
+            }
+            catch {
+                //The service is gone: listened again after the delay
+            }
+            if (abort.signal.aborted || this.#destroyed)
+                break;
+            await new Promise((resolve) => setTimeout(resolve, this.reconnectDelay));
+        }
+        if (this.#events === abort)
+            this.#events = undefined;
+    }
+}
+__decorate([
+    Configurable(DTO.String().uri({ scheme: ['http', 'https'] }).required()),
+    __metadata("design:type", String)
+], HTTPServiceProxy.prototype, "url", void 0);
+__decorate([
+    Configurable(DTO.Object().pattern(DTO.String(), DTO.String()).optional()),
+    __metadata("design:type", Object)
+], HTTPServiceProxy.prototype, "headers", void 0);
+__decorate([
+    Configurable(DTO.String().max(200).optional()),
+    __metadata("design:type", String)
+], HTTPServiceProxy.prototype, "clientId", void 0);
+__decorate([
+    Configurable(DTO.Number().integer().min(0).optional().default(1000)),
+    __metadata("design:type", Number)
+], HTTPServiceProxy.prototype, "reconnectDelay", void 0);

package/dist/esm/adapter/jsonrpc/JSONRPCServiceEntrypoint.js

@@ -4,8 +4,11 @@ import { ServiceChannel } from '../../channel/BuiltinChannels.js';
 import { JSONRPCErrorCode, JSONRPCProtocol } from './JSONRPCProtocol.js';
 import { applicationOf } from '../../lib/ApplicationOf.js';
 import { trackConnections } from '../../lib/Connections.js';
+import { readBody } from '../../lib/ReadBody.js';
+import { preflightHeaders } from '../../lib/Preflight.js';
 /**
- * The headers of the responses of HTTP: the tools of the browsers may call the adapter
+ * The headers of the responses of HTTP: the tools of the browsers may call the adapter; a preflight is allowed the
+ * headers it asks for
  */
 const CORS_HEADERS = {
     'Access-Control-Allow-Origin': '*',
@@ -22,22 +25,6 @@ function clientIdOf(request) {
     const id = Array.isArray(given) ? given[0] : given ?? undefined;
     return id && id.length <= 200 ? id : undefined;
 }
-/**
- * The body of a request, up to a limit
- * @param request
- * @param limit
- */
-async function readBody(request, limit) {
-    const chunks = [];
-    let size = 0;
-    for await (const chunk of request) {
-        size += chunk.length;
-        if (size > limit)
-            throw Object.assign(new Error(`The body of the request is larger than ${limit} bytes`), { status: 413 });
-        chunks.push(chunk);
-    }
-    return Buffer.concat(chunks).toString('utf8');
-}
 /**
  * The messages of a stream framed by lines, or by their Content-Length headers. A message larger than the limit is
  * skipped (the rest of its line, or the length its header declares, keeping the framing) and reported
@@ -130,11 +117,12 @@ function readMessages(input, framing, limit, receive, ended, oversized) {
  * validation, otherwise `SERVER_ERROR` with the whole error object as its `data`.
  *
  * Over HTTP, a message is the body of a `POST` to the path, answered with 200 and the JSON response (204 when it held
- * only notifications); any other method or path is answered with 404, and the CORS headers allow any origin. Over
- * WebSocket and stdio, the events pushed by `Entrypoint.notify` and `Entrypoint.broadcast` are sent as notifications,
- * `{"jsonrpc": "2.0", "method": event, "params": args}`. The client id carried by `ServiceContext.clientId` is the `id`
- * header or `id` query parameter of the HTTP request or of the WebSocket connection (at most 200 characters; a random
- * one for a WebSocket connection without it), and `'stdio'` on stdio.
+ * only notifications); any other method or path is answered with 404. The CORS headers allow any origin, and the
+ * headers a preflight asks for (`Authorization`…). Over WebSocket and stdio, the events pushed by `Entrypoint.notify`
+ * and `Entrypoint.broadcast` are sent as notifications, `{"jsonrpc": "2.0", "method": event, "params": args}`. The
+ * client id carried by `ServiceContext.clientId` is the `id` header or `id` query parameter of the HTTP request or of
+ * the WebSocket connection (at most 200 characters; a random one for a WebSocket connection without it), and `'stdio'`
+ * on stdio.
  *
  * When an HTTP client disconnects before its response, the action's abort signal fires. When the entrypoint stops,
  * stdio stops reading, the new requests are answered with `STOPPING`, and once the requests in progress are answered
@@ -170,7 +158,8 @@ function readMessages(input, framing, limit, receive, ended, oversized) {
  *                 jsonRPCServiceEntrypoint({name: 'rpc-ws', transport: 'websocket', port: 3001, path: '/rpc'})
  *             ]
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * })
  *
  * //An HTTP client: {"jsonrpc": "2.0", "id": 1, "result": {"id": 1, "name": "Ada"}}
@@ -268,7 +257,7 @@ export function jsonRPCServiceEntrypoint(options = {}) {
                 server = createServer((request, response) => {
                     const url = new URL(request.url ?? '/', 'http://localhost');
                     if (request.method === 'OPTIONS')
-                        return void response.writeHead(204, CORS_HEADERS).end();
+                        return void response.writeHead(204, preflightHeaders(request, CORS_HEADERS)).end();
                     if (request.method !== 'POST' || url.pathname !== path) {
                         return void response.writeHead(404, { ...CORS_HEADERS, 'Content-Type': 'application/json' }).end(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32600, message: `POST ${path} receives the requests of JSON-RPC 2.0` } }));
                     }
@@ -286,7 +275,7 @@ export function jsonRPCServiceEntrypoint(options = {}) {
                                 response.writeHead(204, CORS_HEADERS).end();
                         });
                     }, (error) => {
-                        response.writeHead(error.status ?? 400, { ...CORS_HEADERS, 'Content-Type': 'application/json' }).end(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32600, message: error.message } }));
+                        response.writeHead(error.statusCode ?? 400, { ...CORS_HEADERS, 'Content-Type': 'application/json' }).end(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32600, message: error.message } }));
                     });
                 });
                 return await listen(server);

package/dist/esm/adapter/schedule/ScheduleEntrypoint.js

@@ -61,7 +61,8 @@ const MAX_DELAY = 2 ** 31 - 1;
  *                 onSkip: (action, scheduledAt, reason): void => console.warn(`${action.name} skipped (${reason})`)
  *             })
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * })
  * ```
  */
@@ -92,16 +93,22 @@ export function scheduleEntrypoint(options = {}) {
         timers.add(timer);
     };
     /**
-     * Write a failed run to the log of the application
+     * Give a failed run to the onError handler, or write it to the log of the application; an error of the handler is
+     * written to the log
      * @param runtime
      * @param error
      * @param action
      * @param context
      */
     const report = async (runtime, error, action, context) => {
-        if (options.onError)
-            return await options.onError(error, action, context);
-        await log(runtime, error, `The scheduled action ${action.name} (${context.schedule}) failed`);
+        if (!options.onError)
+            return await log(runtime, error, `The scheduled action ${action.name} (${context.schedule}) failed`);
+        try {
+            await options.onError(error, action, context);
+        }
+        catch (handlerError) {
+            await log(runtime, handlerError, `The onError handler of the scheduled action ${action.name} failed`);
+        }
     };
     /**
      * Write an error to the log of the application

package/dist/esm/adapter/socket.io/SocketIOServiceEntrypoint.js

@@ -79,7 +79,8 @@ function clientIdOf(socket) {
  *             controllers: [EchoController],
  *             service: socketIOServiceEntrypoint({port: 3000, options: {cors: {origin: '*'}}})
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * })
  *
  * //A client, identified as client-1 (the events pushed by entrypoint.notify('client-1', 'progress', 50) reach it)

package/dist/esm/channel/BuiltinChannels.js

@@ -1,6 +1,7 @@
 import { getObjectPropertyPaths, uniqueArray } from '@lakutata/utils';
 import { defineChannel } from './Channel.js';
 import { PatternManager } from '../lib/pattern/PatternManager.js';
+import { flattenPattern, flattenSubject } from '../lib/pattern/FlattenPattern.js';
 import { stringifyPattern } from '../lib/StringifyPattern.js';
 import { prefixCommand, prefixPattern, prefixRoute } from '../lib/Prefix.js';
 import { ContextType } from '../context/BaseContext.js';
@@ -74,12 +75,13 @@ export const ServiceChannel = defineChannel({
     describe: (pattern) => ({ pattern: pattern }),
     prefix: (prefix, pattern) => prefix.pattern === undefined ? undefined : prefixPattern(prefix.pattern, pattern),
     createMatcher: (entries) => {
+        //The values of the nested objects are compared one by one: {res: {name: 'user'}} matches as {'res.name': 'user'}
         const patterns = new PatternManager();
         for (const entry of entries)
-            patterns.add(entry.details.pattern, entry);
+            patterns.add(flattenPattern(entry.details.pattern), entry);
         return {
             match: (context) => {
-                const entry = patterns.find(context.input);
+                const entry = patterns.find(flattenSubject(context.input));
                 return entry ? { entry: entry } : undefined;
             }
         };

package/dist/esm/decorators/Schedule.js

@@ -32,8 +32,9 @@ function ScheduleAddress(schedule) {
         address.schedule = `every ${typeof options.every === 'number' ? `${options.every}ms` : options.every}`;
     }
     else if (options.cron !== undefined) {
-        //The expression is checked now, not at the first run
-        new Cron(options.cron, options.timezone);
+        //The expression is checked now, not at the first run; a valid one matching no date (February 30th) would never run
+        if (!new Cron(options.cron, options.timezone).next())
+            throw new SyntaxError(`The cron expression ${options.cron} matches no date`);
         address.cron = options.cron;
         address.schedule = `cron ${options.cron}`;
         if (options.timezone)

package/dist/esm/exceptions/AccessDeniedException.js

@@ -4,10 +4,15 @@ import { Exception } from '@lakutata/core';
  * Its errno is `E_ACCESS_DENY`, its HTTP status 403.
  */
 export class AccessDeniedException extends Exception {
-    constructor() {
-        super(...arguments);
+    /**
+     * Create the exception: its message is "Access denied" unless one is given.
+     * @param template The message, or a template filled from the parameters (see `Exception`), or an error whose
+     * message it takes; "Access denied" by default.
+     * @param params The parameters of the template.
+     */
+    constructor(template, ...params) {
+        super((template ?? 'Access denied'), ...params);
         this.errno = 'E_ACCESS_DENY';
-        this.message = 'Access denied';
         this.statusCode = 403;
     }
 }

package/dist/esm/exceptions/EntrypointStoppedException.js

@@ -1,7 +1,8 @@
 import { Exception } from '@lakutata/core';
 /**
  * The request arrived while the entrypoint is stopping (the application exiting): it is refused, the requests in
- * progress being waited for. Its errno is `E_ENTRYPOINT_STOPPED`, its HTTP status 503.
+ * progress being waited for. A request still running when the entrypoint's `shutdownTimeout` runs out is aborted with
+ * it too. Its errno is `E_ENTRYPOINT_STOPPED`, its HTTP status 503.
  */
 export class EntrypointStoppedException extends Exception {
     constructor() {

package/dist/esm/exceptions/InvalidActionGroupException.js

@@ -1,4 +1,8 @@
 import { Exception } from '@lakutata/core';
+/**
+ * An action is in a group that the `*ActionGroups` option of its channel (`httpActionGroups`, `cliActionGroups`,
+ * `serviceActionGroups`) does not declare, when the entrypoint initializes. Its errno is `E_INVALID_ACTION_GROUP`.
+ */
 export class InvalidActionGroupException extends Exception {
     constructor() {
         super(...arguments);

package/dist/esm/exceptions/ServiceUnavailableException.js

@@ -0,0 +1,14 @@
+import { Exception } from '@lakutata/core';
+/**
+ * A service called by an `HTTPServiceProxy` gave no response: it could not be reached, it did not answer in time, or
+ * its answer was not a service response (the error page of a proxy in front of it…). Its `cause` is the error of the
+ * request when there is one, its `service` the address of the service. Its errno is `E_SERVICE_UNAVAILABLE`, its HTTP
+ * status 503. The failures of the actions themselves are thrown as `ServiceInvokeException`.
+ */
+export class ServiceUnavailableException extends Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_SERVICE_UNAVAILABLE';
+        this.statusCode = 503;
+    }
+}

package/dist/esm/exports/Entrypoint.js

@@ -3,6 +3,7 @@ export * from '../lib/Controller.js';
 export * from '../lib/AccessControlRule.js';
 export * from '../exceptions/AccessDeniedException.js';
 export * from '../exceptions/DuplicateActionNameException.js';
+export * from '../exceptions/InvalidActionGroupException.js';
 export * from '../exceptions/ControllerActionNotFoundException.js';
 export { AccessControl } from '../lib/AccessControl.js';
 export { Middleware } from '../lib/Middleware.js';
@@ -19,4 +20,6 @@ export * from '../exceptions/EntrypointStoppedException.js';
 export * from '../exceptions/ServiceInvokeException.js';
 export { scheduleEntrypoint } from '../adapter/schedule/ScheduleEntrypoint.js';
 export { httpServiceEntrypoint, httpRequestOfContext } from '../adapter/http/HTTPServiceEntrypoint.js';
+export { buildHTTPServiceProxy, HTTPServiceProxy } from '../adapter/http/HTTPServiceProxy.js';
+export * from '../exceptions/ServiceUnavailableException.js';
 export { Cron, parseDuration } from '../lib/schedule/Cron.js';

package/dist/esm/lib/AccessControl.js

@@ -49,7 +49,8 @@ import { As, isSubclassOf } from '@lakutata/utils';
  *     name: 'Report',
  *     components: {
  *         entrypoint: {class: AuditedEntrypoint, controllers: [ReportController]}
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * }))
  * ```
  */

package/dist/esm/lib/AccessControlRule.js

@@ -48,7 +48,8 @@ import { Configurable } from '@lakutata/core/decorator/di';
  *             rules: [AdminRule],
  *             httpActionGroups: {admin: 'Administration'}
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * }))
  * ```
  */

package/dist/esm/lib/ExplicitStatus.js

@@ -0,0 +1,18 @@
+/**
+ * The responses whose status was set by the action (a StatusResult): the default responders keep it, 200 included
+ */
+const explicitStatuses = new WeakSet();
+/**
+ * Mark the status of a response as set by the action
+ * @param response
+ */
+export function markExplicitStatus(response) {
+    explicitStatuses.add(response);
+}
+/**
+ * Whether the status of a response was set by the action
+ * @param response
+ */
+export function hasExplicitStatus(response) {
+    return explicitStatuses.has(response);
+}

package/dist/esm/lib/Middleware.js

@@ -46,7 +46,8 @@ import { MiddlewareNextCalledException } from '../exceptions/MiddlewareNextCalle
  *             controllers: [StatusController],
  *             middlewares: [Timing]
  *         })
- *     }
+ *     },
+ *     bootstrap: ['entrypoint']
  * }))
  * ```
  */