@fougere/core 0.3.0-alpha.0 → 0.5.0-alpha.0

package/src/contract/CallLog.ts

@@ -0,0 +1,55 @@
+import type { DispatchEvent } from '../dispatch/DispatchEvent.js';
+
+/**
+ * What crosses the door: the address, the route it took, and the verdict.
+ *
+ * It lives here rather than beside its producer for the reason `TopologyReport` does: it
+ * crosses a process boundary, so a reader that never installed `@fougere/calls` — the CLI
+ * — needs its shape, and putting it there is what produces a hand-copied duplicate.
+ *
+ * Never the body. Same rule the topology report states — a remote destination is named,
+ * not disclosed — and it holds here for the same reason: this answer leaves the process.
+ */
+export interface CallRecord {
+  /** Monotonic, and the whole cursor protocol: a reader asks for what is above its own. */
+  seq: number;
+  frond?: string;
+  entity: string;
+  operation: string;
+  surface?: string;
+  /** Known at `resolved`, so absent on a call that never found a route. */
+  route?: NonNullable<DispatchEvent['routeKind']>;
+  /**
+   * The traceparent the invocation carried, when one did.
+   *
+   * One panel reads one process, so this is what lets two of them be sewn: the process
+   * that sent and the process that executed share it, and the gap between their two
+   * durations IS the cost of the wire rather than a deduction.
+   */
+  trace?: string;
+  /**
+   * The peer that established this call, when one did.
+   *
+   * A hosted frond serves several consumers, so its own ring mixes them: this is what
+   * separates them. Absent on a call nobody signed — a loopback dev boot has no identity.
+   */
+  caller?: string;
+  startedAt: number;
+  /** Known at `settled`. */
+  ms?: number;
+  verdict: 'running' | 'ok' | 'failed';
+  refusal?: { code?: string; message: string };
+}
+
+/**
+ * One page of the ring.
+ *
+ * `dropped` is what the ring could not keep — an absence is named rather than left to
+ * look like a quiet period.
+ */
+export interface CallPage {
+  calls: CallRecord[];
+  cursor: number;
+  inFlight: number;
+  dropped: number;
+}

package/src/contract/Invocation.ts

@@ -0,0 +1,72 @@
+export interface InvocationContext {
+  params: Record<string, unknown>;
+  query: Record<string, unknown>;
+  body: unknown;
+  state: Record<string, unknown>;
+  trace?: string;
+  identity?: string;
+  caller?: string;
+}
+
+export type InvocationInput = Partial<InvocationContext>;
+
+function canonicalValue(value: unknown): unknown {
+  if (value === null || value === undefined || typeof value !== 'object') return value;
+  if (Array.isArray(value)) return Object.freeze(value.map(canonicalValue));
+
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return value;
+  return canonicalRecord(value);
+}
+
+function canonicalRecord(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return Object.freeze({});
+
+  const result: Record<string, unknown> = {};
+  for (const [key, member] of Object.entries(value)) {
+    if (member !== undefined) result[key] = canonicalValue(member);
+  }
+  return Object.freeze(result);
+}
+
+/** Canonical invocation shared by every entry and transport. */
+export class Invocation implements InvocationContext {
+  readonly params: Record<string, unknown>;
+  readonly query: Record<string, unknown>;
+  readonly body: unknown;
+  readonly state: Record<string, unknown>;
+  readonly trace?: string;
+  readonly identity?: string;
+  readonly caller?: string;
+
+  private constructor(input: InvocationInput) {
+    this.params = canonicalRecord(input.params);
+    this.query = canonicalRecord(input.query);
+    this.body = canonicalValue(input.body);
+    // State is host-owned and may still be enriched by existing middlewares. Moving it
+    // to immutable lifecycle context is a separate migration.
+    this.state = input.state ?? {};
+    if (input.trace !== undefined) this.trace = input.trace;
+    if (input.identity !== undefined) this.identity = input.identity;
+    if (input.caller !== undefined) this.caller = input.caller;
+    Object.freeze(this);
+  }
+
+  static from(input?: InvocationInput): Invocation {
+    return input instanceof Invocation ? input : new Invocation(input ?? {});
+  }
+
+  withBody(body: unknown): Invocation {
+    return new Invocation({ ...this, body });
+  }
+
+  withState(state: Record<string, unknown>): Invocation {
+    return new Invocation({ ...this, state });
+  }
+}
+
+export const EMPTY_INVOCATION = Invocation.from();
+
+export function canonicalInvocation(input?: InvocationInput): Invocation {
+  return Invocation.from(input);
+}

package/src/contract/RouteAddress.ts

@@ -0,0 +1,49 @@
+export interface RouteAddressInput {
+  entity: string;
+  operation: string;
+  surface?: string;
+}
+
+function required(value: string, name: string): string {
+  if (value.trim().length === 0) throw new TypeError(`Route ${name} cannot be empty`);
+  return value;
+}
+
+function optional(value: string | undefined, name: string): string | undefined {
+  return value === undefined ? undefined : required(value, name);
+}
+
+/** Canonical identity of one callable operation. */
+export class RouteAddress {
+  readonly entity: string;
+  readonly operation: string;
+  readonly surface?: string;
+
+  constructor(input: RouteAddressInput) {
+    this.entity = required(input.entity, 'entity');
+    this.operation = required(input.operation, 'operation');
+    this.surface = optional(input.surface, 'surface');
+    Object.freeze(this);
+  }
+
+  key(): string {
+    return JSON.stringify([this.surface ?? null, this.entity, this.operation]);
+  }
+
+  equals(other: RouteAddress): boolean {
+    return this.key() === other.key();
+  }
+
+  toString(): string {
+    const audience = this.surface ? `${this.surface}/` : '';
+    return `${audience}${this.entity}.${this.operation}`;
+  }
+
+  toJSON(): RouteAddressInput {
+    return {
+      entity: this.entity,
+      operation: this.operation,
+      ...(this.surface !== undefined ? { surface: this.surface } : {}),
+    };
+  }
+}

package/src/contract.ts

@@ -0,0 +1,83 @@
+/**
+ * Contract surface — what a sender needs to speak to a receiver, and
+ * nothing that assumes a runtime: the error vocabulary, the invocation
+ * shape, the call value, the naming convention.
+ *
+ * Browser-safe by design: no node builtin may enter this module's import
+ * graph. Published as the `@fougere/core/contract` subpath so client
+ * bundles never touch the full index (scanner, config loader). `@fougere/schema`
+ * is allowed in — measured, it imports no node builtin either.
+ */
+import { lowerFirst } from '@fougere/schema';
+import { canonicalInvocation, type InvocationContext } from './contract/Invocation.js';
+import type { FrondCall } from './wire/call.js';
+
+export { FougereError, ErrorCode, validationErrorsOf } from './wire/errors.js';
+// A receiver turns a refusal into what may cross a process boundary, and it is not
+// core's boot — reaching it through the main entry dragged the scanner into a bundle.
+export { toPublicError } from './wire/http-error.js';
+export type { FougereErrorOptions } from './wire/errors.js';
+export { canonicalInvocation, EMPTY_INVOCATION } from './contract/Invocation.js';
+export type { InvocationContext } from './contract/Invocation.js';
+export { Invocation } from './contract/Invocation.js';
+export type { InvocationInput } from './contract/Invocation.js';
+export { Call } from './contract/Call.js';
+export { RouteAddress } from './contract/RouteAddress.js';
+export type { RouteAddressInput } from './contract/RouteAddress.js';
+export type { FrondCall, Transport, SignedCall } from './wire/call.js';
+export { MAX_BODY_BYTES } from './wire/call.js';
+// The reserved entity, VALUE and not type: a consumer that wants to leave it alone — a
+// call log ignoring its own reader — has to be able to name it.
+export { RPC_ENTITY } from './wire/call.js';
+export type { CallPage, CallRecord } from './contract/CallLog.js';
+// The comparison of two cards, which a consumer runs about a producer — browser-safe on
+// purpose: a panel showing the drift holds only the two cards, never the app.
+export { driftOf, agrees, explain } from './wire/drift.js';
+export type { CardDrift } from './wire/drift.js';
+
+/**
+ * What `rpc.discover` answers. It belongs here and not to the runtime: the
+ * reserved op travels on the same wire as every other call, so a consumer that
+ * only sends — a browser bundle, a frond written elsewhere — needs its shape and
+ * nothing else. Type-only, so `call.js` never enters the runtime graph.
+ *
+ * Stated once, on purpose: two private copies of this interface have already gone
+ * stale (the CLI's, then the Rust demo's) the day an op stopped being a bare name.
+ */
+export type { IdentityCard, CardOp, TopologyReport, FrondPlacement, Edge } from './wire/call.js';
+export { assertIdentityCard } from './wire/call.js';
+
+/**
+ * The key a class name is filed under — 'Post' → 'post'. Re-exported rather than
+ * respelled: a card writes it and a foreign key derives from it, so the convention
+ * belongs to the schema, and a second copy here is a second opinion. It travels
+ * through this subpath because a consumer of the wire (a browser bundle) may hold no
+ * schema dependency of its own — that audience only. Inside the package it is read from
+ * `@fougere/schema` directly: routing four modules through here bought nothing and put
+ * this file inside a cycle.
+ */
+export { lowerFirst } from '@fougere/schema';
+
+/** A call, fully fabricated: the designation and its completed invocation. */
+export interface CallValue {
+  call: FrondCall;
+  invocation: InvocationContext;
+}
+
+/**
+ * Fabricate the call value — one designation, two spellings:
+ * `callValueOf(Post, 'list', { query })` (class + verb) or
+ * `callValueOf({ entity, op }, input)` (raw, for dynamic bridges).
+ * Missing invocation fields complete to the empty invocation.
+ */
+export function callValueOf(
+  target: { name: string } | FrondCall,
+  opOrInput?: string | Partial<InvocationContext>,
+  input?: Partial<InvocationContext>,
+): CallValue {
+  const [call, given] =
+    typeof opOrInput === 'string'
+      ? [{ entity: lowerFirst((target as { name: string }).name), op: opOrInput }, input]
+      : [target as FrondCall, opOrInput];
+  return { call, invocation: canonicalInvocation(given) };
+}

package/src/crypto/encoding.ts

@@ -0,0 +1,59 @@
+/**
+ * What both realizations spell identically — bytes in, bytes out, no platform.
+ *
+ * `Buffer` did all of this and does not exist on a Worker; `atob`/`btoa` exist on both.
+ * Nothing here is a policy decision, which is why it sits beside the port rather than
+ * inside either half: two copies of a base64url would be two chances to disagree on the
+ * padding, and the disagreement would show up as a bad signature.
+ */
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
+export const bytesOf = (text: string): Uint8Array => encoder.encode(text);
+export const textOf = (bytes: Uint8Array): string => decoder.decode(bytes);
+
+/** Base64url, unpadded — what JWS puts between the dots. */
+export function b64url(input: Uint8Array | string): string {
+  const bytes = typeof input === 'string' ? bytesOf(input) : input;
+  let binary = '';
+  // One character at a time: `String.fromCharCode(...bytes)` overflows the argument
+  // limit on a key, and a signature is small enough that the loop costs nothing.
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+
+export function unb64url(input: string): Uint8Array {
+  const binary = atob(input.replace(/-/g, '+').replace(/_/g, '/'));
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+
+/** Plain base64, padded — what an environment variable carries a PEM as. */
+export function b64(input: Uint8Array | string): string {
+  const bytes = typeof input === 'string' ? bytesOf(input) : input;
+  let binary = '';
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+
+export const unb64 = (input: string): Uint8Array => {
+  const binary = atob(input);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+};
+
+/**
+ * The DER a PEM wraps. WebCrypto imports DER and knows nothing about the armour.
+ *
+ * The label is not checked: a caller asking for a private key and handed a public one
+ * fails at `importKey` with a message about the key, which is the truer error than one
+ * about a header line.
+ */
+export function derOf(pem: string): Uint8Array {
+  const body = pem.replace(/-----(BEGIN|END)[^-]+-----/g, '').replace(/\s+/g, '');
+  if (body.length === 0) throw new Error('Not a PEM: no base64 body between the armour');
+  return unb64(body);
+}

package/src/crypto/node.ts

@@ -0,0 +1,30 @@
+/**
+ * Ed25519 through `node:crypto` — the default realization, and the fast one.
+ *
+ * `sign`/`verify` are synchronous here and stay synchronous: the promise is put around
+ * the answer, never around the work. That is the whole reason this file exists rather
+ * than everyone sharing the WebCrypto half.
+ */
+import { createHash, createPrivateKey, createPublicKey, sign, verify } from 'node:crypto';
+import type { CryptoPort, PublicJwk, Signer, Verifier } from './port.js';
+
+export const crypto: CryptoPort = {
+  async sha256(data) {
+    return new Uint8Array(createHash('sha256').update(data).digest());
+  },
+
+  async signerOf(privateKeyPem): Promise<Signer> {
+    // Parsed here and captured, so a call signs against a KeyObject and never a string.
+    const key = createPrivateKey(privateKeyPem);
+    return { async sign(data) { return new Uint8Array(sign(null, data, key)); } };
+  },
+
+  async verifierOf(key): Promise<Verifier> {
+    const parsed = typeof key === 'string'
+      ? createPublicKey(key)
+      : createPublicKey({ key: key as never, format: 'jwk' });
+    return { async verify(data, signature) { return verify(null, data, parsed, signature); } };
+  },
+};
+
+export type { CryptoPort, PublicJwk, Signer, Verifier };

package/src/crypto/port.ts

@@ -0,0 +1,45 @@
+/**
+ * The two Ed25519 gestures a signed call needs, and the one hash that binds it.
+ *
+ * Node signs 59% faster than WebCrypto on the same curve (measured 2026-08-23: 14.30 µs
+ * against 22.72 µs per signature, 34.42 against 41.81 to verify), so this is a PORT with
+ * two realizations and not one implementation at the lowest common denominator. `#crypto`
+ * resolves to `crypto/node.ts` everywhere except under the `workerd` condition — the
+ * bundler picks at build time, and neither half ever appears in the other's output.
+ *
+ * The shape is async because WebCrypto is. On Node that costs one microtask, which the
+ * same measurement puts inside the noise of the signature itself (14.30 sync against
+ * 14.28 awaited) — awaiting is free, converting is not.
+ *
+ * A KEY IS PARSED ONCE. `crypto.subtle.importKey` is async and per-key, so an interface
+ * shaped `sign(key, data)` would import on every call; `signerOf(pem)` hands back
+ * something that holds the parsed key, and a boot builds it once.
+ */
+
+/** A parsed private key. */
+export interface Signer {
+  sign(data: Uint8Array): Promise<Uint8Array>;
+}
+
+/** A parsed public key. */
+export interface Verifier {
+  /** False, never a throw: a bad signature is an answer, not a failure. */
+  verify(data: Uint8Array, signature: Uint8Array): Promise<boolean>;
+}
+
+/** A public key as a grant carries it — `{ kty: 'OKP', crv: 'Ed25519', x }`. */
+export interface PublicJwk {
+  kty: string;
+  crv?: string;
+  x?: string;
+  [key: string]: unknown;
+}
+
+export interface CryptoPort {
+  /** SHA-256. What binds a body to an envelope without carrying the body. */
+  sha256(data: Uint8Array): Promise<Uint8Array>;
+  /** From a PKCS#8 PEM — what `fougere keys` writes. */
+  signerOf(privateKeyPem: string): Promise<Signer>;
+  /** From an SPKI PEM (the root's) or a JWK (the one a grant embeds). */
+  verifierOf(key: string | PublicJwk): Promise<Verifier>;
+}

package/src/crypto/webcrypto.ts

@@ -0,0 +1,55 @@
+/**
+ * Ed25519 through WebCrypto — what a runtime with no `node:` builtin has.
+ *
+ * Verified in real workerd with no compatibility flag (2026-08-23): sign, verify, a JWK
+ * import, an SPKI import and SHA-256 all answer. `Ed25519` is the algorithm name; the
+ * older `NODE-ED25519` spelling is not used, and a runtime that only knows that one will
+ * refuse at `importKey` rather than silently signing with something else.
+ *
+ * The four gestures are declared here rather than pulled from `lib.dom`: this package
+ * compiles with `lib: ["ESNext"]` and naming DOM would make every consumer carry a
+ * browser's globals to read a server type. What the file needs IS the declaration.
+ */
+import { derOf } from './encoding.js';
+import type { CryptoPort, PublicJwk, Signer, Verifier } from './port.js';
+
+interface WebSubtle {
+  digest(algorithm: string, data: Uint8Array): Promise<ArrayBuffer>;
+  importKey(
+    format: 'pkcs8' | 'spki' | 'jwk',
+    key: Uint8Array | PublicJwk,
+    algorithm: { name: string },
+    extractable: boolean,
+    usages: string[],
+  ): Promise<unknown>;
+  sign(algorithm: { name: string }, key: unknown, data: Uint8Array): Promise<ArrayBuffer>;
+  verify(algorithm: { name: string }, key: unknown, signature: Uint8Array, data: Uint8Array): Promise<boolean>;
+}
+
+const ED25519 = { name: 'Ed25519' } as const;
+
+/** Read at call time — a Worker has the global, and reading it at module load does not. */
+const subtle = (): WebSubtle =>
+  (globalThis as unknown as { crypto: { subtle: WebSubtle } }).crypto.subtle;
+
+export const crypto: CryptoPort = {
+  async sha256(data) {
+    return new Uint8Array(await subtle().digest('SHA-256', data));
+  },
+
+  async signerOf(privateKeyPem): Promise<Signer> {
+    // Imported once, at boot. Doing it per call would put an async key parse inside
+    // every outgoing request — the reason the port hands back a signer at all.
+    const key = await subtle().importKey('pkcs8', derOf(privateKeyPem), ED25519, false, ['sign']);
+    return { async sign(data) { return new Uint8Array(await subtle().sign(ED25519, key, data)); } };
+  },
+
+  async verifierOf(key): Promise<Verifier> {
+    const imported = typeof key === 'string'
+      ? await subtle().importKey('spki', derOf(key), ED25519, false, ['verify'])
+      : await subtle().importKey('jwk', key, ED25519, false, ['verify']);
+    return { verify: (data, signature) => subtle().verify(ED25519, imported, signature, data) };
+  },
+};
+
+export type { CryptoPort, PublicJwk, Signer, Verifier };

package/src/define.ts

@@ -0,0 +1,10 @@
+import type { FougereConfig } from './config-loader.js';
+
+/**
+ * Identity helper for fougere.config.ts — preserves literal types for autocomplete
+ * while validating against FougereConfig. Equivalent to `satisfies FougereConfig`
+ * but more explicit and aligned with defineFrond().
+ */
+export function defineFougere<T extends FougereConfig>(config: T): T {
+  return config;
+}

package/src/dispatch/ArgumentResolver.ts

@@ -0,0 +1,17 @@
+import {
+  resolveArgs,
+  type BindingPlan,
+  type CollectorResolver,
+} from '../boot/binding.js';
+import type { InvocationContext } from '../contract/Invocation.js';
+
+export type CollectorLookup = (typeName: string) => CollectorResolver | undefined;
+
+/** Resolves an operation's declared binding plan against one invocation. */
+export class ArgumentResolver {
+  constructor(private readonly collectors?: CollectorLookup) {}
+
+  resolve(plan: BindingPlan, invocation: InvocationContext): Promise<unknown[]> {
+    return resolveArgs(plan, invocation, this.collectors);
+  }
+}

package/src/dispatch/ArrayResult.ts

@@ -0,0 +1,10 @@
+/** Preserve the named properties carried by a list result when its rows are replaced. */
+export function preserveArrayProperties<T extends unknown[]>(source: unknown[], target: T): T {
+  for (const key of Object.keys(source)) {
+    if (!/^\d+$/.test(key)) {
+      (target as unknown as Record<string, unknown>)[key] =
+        (source as unknown as Record<string, unknown>)[key];
+    }
+  }
+  return target;
+}

package/src/dispatch/DispatchEvent.ts

@@ -0,0 +1,38 @@
+import type { Call } from '../contract/Call.js';
+import type { RouteKind } from './Route.js';
+
+export type DispatchStage = 'received' | 'resolved' | 'completed' | 'failed' | 'settled';
+
+/** Immutable transition observed across one dispatch lifecycle. */
+export class DispatchEvent {
+  private constructor(
+    readonly stage: DispatchStage,
+    readonly call: Call,
+    readonly routeKind?: RouteKind,
+    readonly error?: unknown,
+  ) {
+    Object.freeze(this);
+  }
+
+  static received(call: Call): DispatchEvent {
+    return new DispatchEvent('received', call);
+  }
+
+  static resolved(call: Call, routeKind: RouteKind): DispatchEvent {
+    return new DispatchEvent('resolved', call, routeKind);
+  }
+
+  static completed(call: Call, routeKind: RouteKind): DispatchEvent {
+    return new DispatchEvent('completed', call, routeKind);
+  }
+
+  static failed(call: Call, error: unknown, routeKind?: RouteKind): DispatchEvent {
+    return new DispatchEvent('failed', call, routeKind, error);
+  }
+
+  static settled(call: Call, routeKind?: RouteKind): DispatchEvent {
+    return new DispatchEvent('settled', call, routeKind);
+  }
+}
+
+export type DispatchObserver = (event: DispatchEvent) => void;

package/src/dispatch/DispatchLifecycle.ts

@@ -0,0 +1,43 @@
+import type { DispatchEvent, DispatchObserver } from './DispatchEvent.js';
+
+/** Publishes dispatch transitions without participating in dispatch decisions. */
+export class DispatchLifecycle {
+  private readonly observers: DispatchObserver[];
+
+  constructor(
+    observers: readonly DispatchObserver[] = [],
+    private readonly diagnose: (error: unknown, event: DispatchEvent) => void = () => {},
+  ) {
+    this.observers = [...observers];
+  }
+
+  /**
+   * Subscribe after the dispatcher was built, and get the unsubscription back.
+   *
+   * The list used to be settled at construction, so only the caller of `createApp` could
+   * observe — an extension, which runs in `up(app)`, could not. `app.use` already adds a
+   * middleware this late; this is its dual, and the pair is *participate* / *watch*.
+   */
+  add(observer: DispatchObserver): () => void {
+    this.observers.push(observer);
+
+    return () => {
+      const at = this.observers.indexOf(observer);
+      if (at !== -1) this.observers.splice(at, 1);
+    };
+  }
+
+  publish(event: DispatchEvent): void {
+    for (const observer of this.observers) {
+      try {
+        observer(event);
+      } catch (error) {
+        try {
+          this.diagnose(error, event);
+        } catch {
+          // Diagnostics remain observational too.
+        }
+      }
+    }
+  }
+}

package/src/dispatch/DispatchPort.ts

@@ -0,0 +1,6 @@
+import type { Call } from '../contract/Call.js';
+
+/** The only capability an entry needs. */
+export interface DispatchPort {
+  dispatch(call: Call): Promise<unknown>;
+}

package/src/dispatch/Dispatcher.ts

@@ -0,0 +1,48 @@
+import type { Call } from '../contract/Call.js';
+import { DispatchEvent } from './DispatchEvent.js';
+import { DispatchLifecycle } from './DispatchLifecycle.js';
+import type { DispatchPort } from './DispatchPort.js';
+import type { Route } from './Route.js';
+import type { RoutePolicy } from './RoutePolicy.js';
+import { RouteRegistry } from './RouteRegistry.js';
+import { RouteNotFoundError } from './RouteNotFoundError.js';
+import type { InFlight } from './InFlight.js';
+
+/** Resolves and executes every call through the same transverse lifecycle. */
+export class Dispatcher implements DispatchPort {
+  constructor(
+    private readonly routes: RouteRegistry,
+    private readonly inFlight: InFlight,
+    private readonly lifecycle = new DispatchLifecycle(),
+    private readonly policy?: RoutePolicy,
+  ) {}
+
+  async dispatch(call: Call): Promise<unknown> {
+    let route: Route | undefined;
+    let release: (() => void) | undefined;
+    this.lifecycle.publish(DispatchEvent.received(call));
+
+    try {
+      release = this.inFlight.enter(call.address.entity, call.address.operation);
+      const known = this.routes.find(call.address);
+      const resolved = known ?? await this.routes.resolve(call.address);
+      route = resolved && (!this.policy || this.policy.accepts(resolved)) ? resolved : undefined;
+      if (!route) {
+        throw this.policy?.notFound?.(call, this.routes.routes())
+          ?? new RouteNotFoundError(call, this.routes.routes(), this.policy);
+      }
+
+      this.lifecycle.publish(DispatchEvent.resolved(call, route.kind));
+      const result = await route.execute(call);
+      this.lifecycle.publish(DispatchEvent.completed(call, route.kind));
+      return result;
+    } catch (error) {
+      this.lifecycle.publish(DispatchEvent.failed(call, error, route?.kind));
+      throw error;
+    } finally {
+      this.lifecycle.publish(DispatchEvent.settled(call, route?.kind));
+      release?.();
+    }
+  }
+
+}