@toa.io/extensions.exposition 1.0.0-alpha.29 → 1.0.0-alpha.291

package/source/schemas.test.ts

@@ -0,0 +1,31 @@
+import { it } from 'node:test'
+import assert from 'node:assert/strict'
+
+import * as schemas from './schemas.js'
+
+const authorities = { nex: 'nex.toa.io' }
+
+it('should require ip with bouncer', () => {
+  assert.throws(() => schemas.annotation.validate({ authorities, bouncer: {} }))
+  assert.doesNotThrow(() =>
+    schemas.annotation.validate({ authorities, bouncer: {}, ip: 'x-real-ip' })
+  )
+  assert.doesNotThrow(() => schemas.annotation.validate({ authorities, ip: 'x-real-ip' }))
+})
+
+it('should default nothing in bouncer', () => {
+  assert.doesNotThrow(() =>
+    schemas.annotation.validate({
+      authorities,
+      ip: 'x-real-ip',
+      bouncer: { attempts: 5 }
+    })
+  )
+  assert.throws(() =>
+    schemas.annotation.validate({
+      authorities,
+      ip: 'x-real-ip',
+      bouncer: { attempts: 0 }
+    })
+  )
+})

package/source/schemas.ts

@@ -1,13 +1,15 @@
 import { resolve } from 'node:path'
-import schemas from '@toa.io/schemas'
-import type { Query } from './HTTP'
-import type { Node } from './RTD'
+import * as schemas from '@toa.io/schemas'
+import type { Query } from './HTTP/index.js'
+import type { Node } from './RTD/index.js'
+import type { Call } from './RPC/types.js'
 import type { Schema } from '@toa.io/schemas'
-import type { Annotation } from './Annotation'
+import type { Annotation } from './Annotation.js'
 
-const path = resolve(__dirname, '../schemas')
+const path = resolve(import.meta.dirname, '../schemas')
 const namespace = schemas.namespace(path)
 
 export const querystring: Schema<Query> = namespace.schema('querystring')
 export const annotation: Schema<Annotation> = namespace.schema('annotation')
 export const node: Schema<Node> = namespace.schema('node')
+export const call: Schema<Call> = namespace.schema('call')

package/source/service.ts

@@ -0,0 +1,94 @@
+import assert from 'node:assert'
+import { console, traces, type LevelName, type TracesOptions } from 'openspan'
+import { Gateway } from './Gateway.js'
+import { Remotes } from './Remotes.js'
+import { Tree } from './RTD/index.js'
+import { EndpointsFactory } from './Endpoint.js'
+import { families, interceptors } from './directives/index.js'
+import { DirectivesFactory } from './Directive.js'
+import { Composition } from './Composition.js'
+import * as root from './root.js'
+import { ATOM_GROUP, CHANNEL } from './const.js'
+import { Interception } from './Interception.js'
+import { Dispatcher } from './RPC/index.js'
+import { Server as Model } from './MCP/index.js'
+import * as http from './HTTP/index.js'
+import { environment } from '@toa.io/generic'
+import type { Broadcast } from './Gateway.js'
+import type { Connector } from '@toa.io/core'
+import type { Host } from './Factory.js'
+
+/**
+ * The gateway. A composition loads this extension for its tenants alone, so what the
+ * gateway is made of is reached from here and nowhere the factory imports.
+ */
+export async function service(host: Host): Promise<Connector | null> {
+  const properties = environment.get('TOA_EXPOSITION_PROPERTIES')
+
+  assert.ok(properties !== undefined, 'TOA_EXPOSITION_PROPERTIES is undefined')
+
+  configureLogs()
+
+  const options = JSON.parse(properties) as http.Options
+  const broadcast: Broadcast = await host.broadcast(CHANNEL)
+  const server = http.Server.create({ ...options })
+  const remotes = new Remotes(host)
+  const node = root.resolve()
+  const methods = new EndpointsFactory(remotes)
+  const directives = new DirectivesFactory(families, remotes, host, options)
+  const interception = new Interception(interceptors, options)
+  const tree = new Tree(node, methods, directives)
+
+  const composition = new Composition(host)
+  const dispatcher = options.rpc === undefined ? null : new Dispatcher(options.rpc)
+  const mcp = options.mcp === undefined ? null : new Model(options.mcp, tree)
+  const gateway = new Gateway(broadcast, tree, interception, directives, dispatcher, mcp)
+
+  gateway.depends(remotes)
+  gateway.depends(composition)
+  // what the directives meter through; one atom per process, connected once
+  gateway.depends(host.atom(ATOM_GROUP))
+
+  server.attach(gateway.process.bind(gateway))
+  server.depends(gateway)
+
+  return server
+}
+
+const LOGS_PREFIX = 'TOA_TELEMETRY_LOGS'
+const TRACES_ENV = 'TOA_TELEMETRY_TRACES'
+
+function configureLogs(): void {
+  const globEnv = environment.get(LOGS_PREFIX)
+  const level: LevelName = environment.get('TOA_DEV') === '1' ? 'trace' : 'info'
+  const options =
+    globEnv === undefined ? { level } : (JSON.parse(globEnv) as { level?: LevelName })
+
+  console.configure({ level: options.level ?? level })
+
+  const tracesEnv = environment.get(TRACES_ENV)
+  const tracing =
+    tracesEnv === undefined ? development() : (JSON.parse(tracesEnv) as TracesOptions)
+
+  // `openspan` is not Toa's and reads the environment, which no longer holds the context by
+  // the time the exporter is made — so the service is named here
+  if (tracing.exporters?.otlp !== undefined)
+    tracing.exporters.otlp.service ??= environment.get('TOA_CONTEXT')
+
+  traces(tracing)
+}
+
+/**
+ * Tracing is off unless it is configured. The console exporter is a local development
+ * mechanism, so it is turned on for `toa dev` and for a boot trace the CLI has already
+ * asked for (`runtime/boot/src/span.js`), and nowhere else — a deployment that wants
+ * traces annotates `telemetry.traces.exporters`.
+ *
+ * The gateway boots without the telemetry extension, hence the copy of
+ * `extensions/telemetry/source/extension.ts`.
+ */
+function development(): TracesOptions {
+  const local = environment.get('TOA_DEV') === '1' || environment.get('TOA_BOOT_TRACE') === '1'
+
+  return local ? { exporters: { console: {} } } : {}
+}

package/source/shortcuts.ts

@@ -0,0 +1,14 @@
+import type { Shortcuts } from './RTD/syntax/index.js'
+
+/** What a directive may be written as, where the family is implied. */
+export const shortcuts: Shortcuts = new Map([
+  ['anonymous', 'auth:anonymous'],
+  ['anyone', 'auth:anyone'],
+  ['id', 'auth:id'],
+  ['role', 'auth:role'],
+  ['rule', 'auth:rule'],
+  ['incept', 'auth:incept'],
+  ['input', 'io:input'],
+  ['output', 'io:output'],
+  ['languages', 'map:languages']
+])

package/source/userland.ts

@@ -0,0 +1,47 @@
+/**
+ * What Exposition puts into an operation's input, for the operation to be written against.
+ *
+ * The gateway's own types are its business; these are the application's.
+ */
+
+/**
+ * The identity behind the call, as `auth:delegate` embeds it:
+ *
+ * ```yaml
+ * /echo:
+ *   GET:
+ *     auth:assert: true
+ *     auth:delegate: identity
+ *     endpoint: echo
+ * ```
+ *
+ * ```javascript
+ * export async function computation ({ identity }, context) { }
+ * ```
+ */
+export interface Identity {
+  readonly id: string
+
+  /** What the identity holds. Delegation resolves them, so they are always here. */
+  roles: string[]
+
+  permissions?: Record<string, string[]>
+
+  /** How the identity was authenticated; `null` for a transient one. */
+  scheme: string | null
+
+  /** Whether the credentials presented are due to be exchanged. */
+  refresh: boolean
+
+  /** The token's claims, where the identity was federated. */
+  claims?: Claims
+}
+
+/** A federated token's payload: what it must carry, and whatever else the issuer put there. */
+export interface Claims {
+  iss: string
+  sub: string
+  aud?: string | string[]
+
+  [claim: string]: unknown
+}

package/transpiled/Annotation.d.ts

@@ -1,8 +1,70 @@
+import type { Resources } from '@toa.io/operations';
+import type { Protocol } from './HTTP/index.js';
 export interface Annotation {
     authorities: Record<string, string>;
+    /**
+     * `h2c` requires an ingress controller that proxies cleartext HTTP/2 upstream.
+     * See `documentation/protocol.md`.
+     */
+    protocol?: Protocol;
     class?: string;
+    resources?: Resources;
     annotations?: Record<string, string>;
+    /** The Service, as opposed to the Ingress that `annotations` above describes. */
+    service?: {
+        annotations?: Record<string, string>;
+    };
     debug?: boolean;
-    trace?: boolean;
+    /** The header the client address is read from; the connection's without one. See `ip.md`. */
+    ip?: string;
+    /** Failed authentications an address may make; none are metered unless set. See `identity.md`. */
+    bouncer?: Bouncer;
+    /** The authorization server this context exposes; none is exposed without it. */
+    oauth?: OAuth;
+    /** JSON-RPC at `/.rpc`; none is served without it. See `documentation/rpc.md`. */
+    rpc?: RPC;
+    /** MCP at `/.mcp`; none is served without it. See `documentation/mcp.md`. */
+    mcp?: MCP;
     '/'?: object;
 }
+export interface OAuth {
+    /**
+     * Where a client sends the user to consent. The one endpoint of the flow that needs a
+     * person, and so the one this extension does not serve: an application builds it.
+     */
+    authorize: string;
+    /** Paths a token may be restricted to, each advertised as a protected resource. */
+    resources?: string[];
+    /** What a client may ask for. Each is a role, or a scope within one. */
+    scopes?: string[];
+    /** Origins whose Client ID Metadata Documents may be read. None are without it. */
+    trust?: string[];
+    /** Dynamic Client Registration, off unless opened. */
+    registration?: 'open' | 'closed';
+}
+export interface RPC {
+    /**
+     * Calls one request may carry, 32 by default. One request is one authentication and one
+     * reply however many calls it makes, so what a caller may ask for at once is bounded.
+     */
+    batch?: number;
+}
+export interface MCP {
+    /** What the server calls itself, which a client shows a user. */
+    name: string;
+    /** What a model is told before it calls anything here. */
+    instructions?: string;
+    /**
+     * Browser origins the endpoint answers, which the revision requires against DNS rebinding.
+     * None are admitted without it; a request carrying no `Origin` is not a browser's.
+     */
+    origins?: string[];
+    /** Whether the endpoint answers without a credential. It does not unless it says so. */
+    anonymous?: boolean;
+}
+export interface Bouncer {
+    /** what an address may fail at once, 20 by default */
+    attempts?: number;
+    /** seconds it takes to earn them back, 60 by default */
+    interval?: number;
+}

package/transpiled/Annotation.js

@@ -1,3 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};
 //# sourceMappingURL=Annotation.js.map

package/transpiled/Branch.d.ts

@@ -1,7 +1,31 @@
-import type * as RTD from './RTD/syntax';
+import type * as RTD from './RTD/syntax/index.js';
+import type { Node } from './RTD/index.js';
 export interface Branch {
     namespace: string;
     component: string;
     isolated: boolean;
     node: RTD.Node;
+    version: string;
+    /**
+     * When the tenant that announced it started, by its own clock. A replica on its way
+     * out announces the same component with an older stamp than the one replacing it, and
+     * that is what tells the two apart when their versions differ.
+     */
+    timestamp: number;
 }
+/** A branch the gateway has merged, and the tenant it came from. */
+export interface Exposed {
+    version: string;
+    /** The start time of the tenant this branch came from. */
+    timestamp: number;
+    nodes: Node[];
+}
+/**
+ * What to do with an announcement about a component that already has a branch exposed.
+ *
+ * - `refresh`: the same version, so its expiration is extended and its endpoints left alone
+ * - `superseded`: it came from a tenant that started before the one exposed now
+ * - `merge`: everything else
+ */
+export declare function decide(exposed: Exposed, branch: Branch): Decision;
+export type Decision = 'merge' | 'refresh' | 'superseded';

package/transpiled/Branch.js

@@ -1,3 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * What to do with an announcement about a component that already has a branch exposed.
+ *
+ * - `refresh`: the same version, so its expiration is extended and its endpoints left alone
+ * - `superseded`: it came from a tenant that started before the one exposed now
+ * - `merge`: everything else
+ */
+export function decide(exposed, branch) {
+    if (exposed.version === branch.version)
+        return 'refresh';
+    if (branch.timestamp < exposed.timestamp)
+        return 'superseded';
+    return 'merge';
+}
 //# sourceMappingURL=Branch.js.map

package/transpiled/Branch.js.map

@@ -1 +1 @@
-{"version":3,"file":"Branch.js","sourceRoot":"","sources":["../source/Branch.ts"],"names":[],"mappings":""}
+{"version":3,"file":"Branch.js","sourceRoot":"","sources":["../source/Branch.ts"],"names":[],"mappings":"AA4BA;;;;;;GAMG;AACH,MAAM,UAAU,MAAM,CAAC,OAAgB,EAAE,MAAc;IACrD,IAAI,OAAO,CAAC,OAAO,KAAK,MAAM,CAAC,OAAO;QAAE,OAAO,SAAS,CAAA;IAExD,IAAI,MAAM,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS;QAAE,OAAO,YAAY,CAAA;IAE7D,OAAO,OAAO,CAAA;AAChB,CAAC"}

package/transpiled/Composition.d.ts

@@ -1,10 +1,9 @@
 import { Connector } from '@toa.io/core';
-import { type Bootloader } from './Factory';
+import { type Host } from './Factory.js';
 export declare class Composition extends Connector {
-    private readonly boot;
-    constructor(boot: Bootloader);
+    private readonly host;
+    constructor(host: Host);
     protected open(): Promise<void>;
-    protected dispose(): void;
 }
 export declare function components(): Components;
 interface Components {

package/transpiled/Composition.js

@@ -1,43 +1,34 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.components = exports.Composition = void 0;
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
-const core_1 = require("@toa.io/core");
-class Composition extends core_1.Connector {
-    boot;
-    constructor(boot) {
+import { readdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { Connector } from '@toa.io/core';
+export class Composition extends Connector {
+    host;
+    constructor(host) {
         super();
-        this.boot = boot;
+        this.host = host;
     }
     async open() {
         const paths = find();
-        const composition = await this.boot.composition(paths);
+        const composition = await this.host.composition(paths);
         await composition.connect();
         this.depends(composition);
-        console.info('Composition complete.');
-    }
-    dispose() {
-        console.info('Composition shutdown complete.');
     }
 }
-exports.Composition = Composition;
 function find() {
-    return entries().map((entry) => (0, node_path_1.resolve)(ROOT, entry.name));
+    return entries().map((entry) => resolve(ROOT, entry.name));
 }
 function entries() {
-    const entries = (0, node_fs_1.readdirSync)(ROOT, { withFileTypes: true });
+    const entries = readdirSync(ROOT, { withFileTypes: true });
     return entries.filter((entry) => entry.isDirectory());
 }
-function components() {
+export function components() {
     const labels = [];
     const paths = [];
     for (const entry of entries()) {
         labels.push(entry.name.replace('.', '-'));
-        paths.push((0, node_path_1.resolve)(ROOT, entry.name));
+        paths.push(resolve(ROOT, entry.name));
     }
     return { labels, paths };
 }
-exports.components = components;
-const ROOT = (0, node_path_1.resolve)(__dirname, '../components/');
+const ROOT = resolve(import.meta.dirname, '../components/');
 //# sourceMappingURL=Composition.js.map

package/transpiled/Composition.js.map

@@ -1 +1 @@
-{"version":3,"file":"Composition.js","sourceRoot":"","sources":["../source/Composition.ts"],"names":[],"mappings":";;;AAAA,qCAAkD;AAClD,yCAAmC;AACnC,uCAAwC;AAGxC,MAAa,WAAY,SAAQ,gBAAS;IACvB,IAAI,CAAY;IAEjC,YAAoB,IAAgB;QAClC,KAAK,EAAE,CAAA;QACP,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;IAClB,CAAC;IAEkB,KAAK,CAAC,IAAI;QAC3B,MAAM,KAAK,GAAG,IAAI,EAAE,CAAA;QACpB,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAA;QAEtD,MAAM,WAAW,CAAC,OAAO,EAAE,CAAA;QAE3B,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAA;QAEzB,OAAO,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAA;IACvC,CAAC;IAEkB,OAAO;QACxB,OAAO,CAAC,IAAI,CAAC,gCAAgC,CAAC,CAAA;IAChD,CAAC;CACF;AAtBD,kCAsBC;AAED,SAAS,IAAI;IACX,OAAO,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAA,mBAAO,EAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAA;AAC5D,CAAC;AAED,SAAS,OAAO;IACd,MAAM,OAAO,GAAG,IAAA,qBAAW,EAAC,IAAI,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAA;IAE1D,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,CAAA;AACvD,CAAC;AAED,SAAgB,UAAU;IACxB,MAAM,MAAM,GAAa,EAAE,CAAA;IAC3B,MAAM,KAAK,GAAa,EAAE,CAAA;IAE1B,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,EAAE,CAAC;QAC9B,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAA;QACzC,KAAK,CAAC,IAAI,CAAC,IAAA,mBAAO,EAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAA;IACvC,CAAC;IAED,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAA;AAC1B,CAAC;AAVD,gCAUC;AAOD,MAAM,IAAI,GAAG,IAAA,mBAAO,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAA"}
+{"version":3,"file":"Composition.js","sourceRoot":"","sources":["../source/Composition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAe,MAAM,SAAS,CAAA;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAGxC,MAAM,OAAO,WAAY,SAAQ,SAAS;IACvB,IAAI,CAAM;IAE3B,YAAmB,IAAU;QAC3B,KAAK,EAAE,CAAA;QACP,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;IAClB,CAAC;IAEkB,KAAK,CAAC,IAAI;QAC3B,MAAM,KAAK,GAAG,IAAI,EAAE,CAAA;QACpB,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAA;QAEtD,MAAM,WAAW,CAAC,OAAO,EAAE,CAAA;QAE3B,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAA;IAC3B,CAAC;CACF;AAED,SAAS,IAAI;IACX,OAAO,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAA;AAC5D,CAAC;AAED,SAAS,OAAO;IACd,MAAM,OAAO,GAAG,WAAW,CAAC,IAAI,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAA;IAE1D,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,CAAA;AACvD,CAAC;AAED,MAAM,UAAU,UAAU;IACxB,MAAM,MAAM,GAAa,EAAE,CAAA;IAC3B,MAAM,KAAK,GAAa,EAAE,CAAA;IAE1B,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,EAAE,CAAC;QAC9B,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAA;QACzC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAA;IACvC,CAAC;IAED,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAA;AAC1B,CAAC;AAOD,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAA"}

package/transpiled/Context.d.ts

@@ -1,7 +1,8 @@
-import type * as RTD from './RTD';
-export type Context = RTD.Context<Extension>;
+import type * as RTD from './RTD/index.js';
+export type Context = RTD.Context<Extension | undefined>;
 interface Extension {
     namespace: string;
     component: string;
+    version: string;
 }
 export {};

package/transpiled/Context.js

@@ -1,3 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};
 //# sourceMappingURL=Context.js.map

package/transpiled/Directive.d.ts

@@ -1,18 +1,43 @@
-import type { Context, OutgoingMessage } from './HTTP';
-import type { Remotes } from './Remotes';
-import type { Output } from './io';
-import type * as RTD from './RTD';
+import type { Context, OutgoingMessage, Options } from './HTTP/index.js';
+import type { Remotes } from './Remotes.js';
+import type { Host } from './Factory.js';
+import type { Output } from './io.js';
+import type { Introspection } from './Introspection.js';
+import type * as RTD from './RTD/index.js';
 export declare class Directives implements RTD.Directives {
     private readonly sets;
+    /** the span of a stage depends only on the set, so it is built once per route */
+    private readonly spans;
     constructor(sets: RTD.DirectiveSet[]);
-    preflight(context: Context, parameters: RTD.Parameter[]): Promise<Output>;
+    declared<T>(family: string): T[] | undefined;
+    precall(context: Context, parameters: RTD.Parameter[]): Promise<Output>;
+    /**
+     * What the method says about itself, as its directives leave it. Each family is given
+     * what the one before it returned, and the first to refuse ends it: a method this caller
+     * cannot reach is not described at all.
+     */
+    explain(context: Context, introspection: Introspection): Promise<Introspection | null>;
     settle(context: Context, response: OutgoingMessage): Promise<void>;
+    dispose(): void;
 }
 export declare class DirectivesFactory implements RTD.DirectiveFactory {
     private readonly remotes;
     private readonly families;
     private readonly mandatory;
-    constructor(families: RTD.DirectiveFamily[], remotes: Remotes);
-    create(declarations: RTD.syntax.Directive[]): Directives;
+    private readonly instances;
+    /** The request-scoped stages, in registration order, with the spans they run in. */
+    private readonly stages;
+    constructor(families: RTD.DirectiveFamily[], remotes: Remotes, host: Host, options: Options);
+    /**
+     * Request-scoped, before anything is routed, so no directives are passed: a family
+     * answers here only for what it does on its own behalf.
+     */
+    preflight(context: Context): Promise<void>;
+    /** Request-scoped, on the message going back. */
+    depart(context: Context, response: OutgoingMessage): Promise<void>;
+    create(declarations: RTD.syntax.Directive[], route?: string): Directives;
+    inheritable(directive: RTD.syntax.Directive): boolean;
+    dispose(): void;
+    /** Mandatory families first, in their own order; everything else keeps its own. */
+    private rank;
 }
-export declare const shortcuts: RTD.syntax.Shortcuts;