@fougere/core 0.6.0-alpha.0 → 0.7.0-alpha.0

package/src/contract.ts

@@ -1,15 +1,9 @@
 /**
- * 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.
+ * 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.
  */
 import { lowerFirst } from '@fougere/schema';
-import { canonicalInvocation, type InvocationContext } from './contract/Invocation.js';
+import { canonicalInvocation, type InvocationContext } from './wire/Invocation.js';
 import type { FrondCall } from './wire/call.js';
 
 export { FougereError, ErrorCode, validationErrorsOf } from './wire/errors.js';
@@ -17,45 +11,29 @@ export { FougereError, ErrorCode, validationErrorsOf } from './wire/errors.js';
 // 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 { canonicalInvocation, EMPTY_INVOCATION } from './wire/Invocation.js';
+export type { InvocationContext } from './wire/Invocation.js';
+export { Invocation } from './wire/Invocation.js';
+export type { PartialInvocation } from './wire/Invocation.js';
+export { Call } from './wire/call.js';
+export { RouteAddress } from './wire/RouteAddress.js';
+export type { RouteAddressInput } from './wire/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';
+export type { CallPage, CallRecord } from './wire/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.
- */
+/** What `rpc.discover` answers. */
 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.
- */
+/** The key a class name is filed under — 'Post' → 'post'. */
 export { lowerFirst } from '@fougere/schema';
 
 /** A call, fully fabricated: the designation and its completed invocation. */
@@ -65,10 +43,8 @@ export interface CallValue {
 }
 
 /**
- * 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.
+ * Fabricate the call value — one designation, two spellings: `callValueOf(Post, 'list', { query
+ * })` (class + verb) or `callValueOf({ entity, op }, input)` (raw, for dynamic bridges).
  */
 export function callValueOf(
   target: { name: string } | FrondCall,

package/src/crypto/encoding.ts

@@ -1,11 +1,4 @@
-/**
- * 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.
- */
+/** What both realizations spell identically — bytes in, bytes out, no platform. */
 
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
@@ -45,13 +38,7 @@ export const unb64 = (input: string): Uint8Array => {
   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.
- */
+/** The DER a PEM wraps. */
 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');

package/src/crypto/node.ts

@@ -1,10 +1,4 @@
-/**
- * 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.
- */
+/** Ed25519 through `node:crypto` — the default realization, and the fast one. */
 import { createHash, createPrivateKey, createPublicKey, sign, verify } from 'node:crypto';
 import type { CryptoPort, PublicJwk, Signer, Verifier } from './port.js';
 

package/src/crypto/port.ts

@@ -1,20 +1,4 @@
-/**
- * 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.
- */
+/** The two Ed25519 gestures a signed call needs, and the one hash that binds it. */
 
 /** A parsed private key. */
 export interface Signer {
@@ -36,7 +20,7 @@ export interface PublicJwk {
 }
 
 export interface CryptoPort {
-  /** SHA-256. What binds a body to an envelope without carrying the body. */
+  /** SHA-256. What binds an input to an envelope without carrying the input. */
   sha256(data: Uint8Array): Promise<Uint8Array>;
   /** From a PKCS#8 PEM — what `fougere keys` writes. */
   signerOf(privateKeyPem: string): Promise<Signer>;

package/src/crypto/webcrypto.ts

@@ -1,15 +1,4 @@
-/**
- * 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.
- */
+/** Ed25519 through WebCrypto — what a runtime with no `node:` builtin has. */
 import { derOf } from './encoding.js';
 import type { CryptoPort, PublicJwk, Signer, Verifier } from './port.js';
 

package/src/declare.ts

@@ -1,20 +1,4 @@
-/**
- * A frond stated by its author, for an app that will not scan.
- *
- * The scan reads the type checker because a signature IS a declaration — and that reading
- * has to happen while the types still exist, which is build time. An app that wants
- * neither a build step nor `typescript` at runtime says the same thing here instead, and
- * `createApp` cannot tell the difference: it consumes a `ScanResult`, never a scanner.
- *
- * What it does NOT ask for is the point. Every name the scan derives from a class is
- * derived here the same way — `PostHandler` answers at `post`, `Post` is stored as `post`
- * — so a declaration states classes and nothing else. `filePath` is empty because there is
- * no file to point at, and a diagnostic that would have quoted one says so plainly.
- *
- * Measured on `demos/nuxt-blog`: 23 of its 29 operations need no word here at all, because
- * `Crud.__ops` declares them at runtime. Only the six the author wrote by hand cost
- * anything, and they cost `frond.config.ts` — where what is not derivable is stated.
- */
+/** A frond stated by its author, for an app that will not scan. */
 import { lowerFirst, type SchemaView } from '@fougere/schema';
 import type {
   CollectorEntry, EntityEntry, FrondDescriptor, HandlerEntry,
@@ -26,13 +10,7 @@ import { getPresenterFields } from './prefab/presenter.js';
 /** A class, as a declaration hands it over: the constructor itself. */
 type Ctor = new (...args: never[]) => unknown;
 
-/**
- * What a subject needs beyond its class, when its constructor names a frame or a port.
- *
- * `deps` is the one thing no runtime can recover: TypeScript erases the parameter types,
- * and `registerFrames` reads them to know which frames to build — asking for one IS
- * declaring it. A handler that takes only its own entity's storage needs nothing here.
- */
+/** What a subject needs beyond its class, when its constructor names a frame or a port. */
 export interface DeclaredSubject {
   ctor: Ctor;
   deps?: string[];
@@ -41,9 +19,9 @@ export interface DeclaredSubject {
 /** A handler, and the surface it answers on when it is not the default one. */
 export interface DeclaredHandler extends DeclaredSubject {
   /**
-   * The scan reads this from the directory (`handlers/public/`), so a statement has to
-   * say it: two handlers over one entity collide on their address otherwise, and the
-   * refusal names the same route twice.
+   * The scan reads this from the directory (`handlers/public/`), so a statement has to say it: two
+   * handlers over one entity collide on their address otherwise, and the refusal names the same
+   * route twice.
    */
   surface?: string;
 }
@@ -55,9 +33,8 @@ const ctorOf = (d: Declared): Ctor => (typeof d === 'function' ? d : d.ctor);
 
 /**
  * What a prefab was BUILT ON — `Presenter(Post)` and `Collector(User)` both keep it under
- * `__entity`, which is the only place it survives: nothing in the FORM of `PostPresenter`
- * says `Post`. Absent, the class did not come through the prefab, and the refusal says so
- * rather than yielding a frond whose presenter belongs to no entity.
+ * `__entity`, which is the only place it survives: nothing in the FORM of `PostPresenter` says
+ * `Post`.
  */
 function subjectOf(ctor: Ctor, kind: string): { name: string } {
   const subject = (ctor as unknown as { __entity?: { name: string } }).__entity;
@@ -93,15 +70,7 @@ export interface FrondDeclaration {
   scope?: string;
 }
 
-/**
- * State a frond without reading a disk.
- *
- * ```ts
- * createApp({
- *   scan: { fronds: Fronds.hosting([frond('blog', { entities: [Post], handlers: [PostHandler] })]), diagnostics: [] },
- * })
- * ```
- */
+/** State a frond without reading a disk. */
 export function frond(name: string, declared: FrondDeclaration = {}): FrondDescriptor {
   const scope = declared.scope ?? DEFAULT_CONVENTIONS.scope;
 

package/src/define.ts

@@ -1,9 +1,8 @@
 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().
+ * Identity helper for fougere.config.ts — preserves literal types for autocomplete while
+ * validating against FougereConfig.
  */
 export function defineFougere<T extends FougereConfig>(config: T): T {
   return config;

package/src/descriptor/Fronds.ts

@@ -1,19 +1,7 @@
 import type { SchemaView } from '@fougere/schema';
 import type { EntityEntry, FrondDescriptor } from './frond.js';
 
-/**
- * What this app hosts, with the questions everyone was asking it by hand.
- *
- * The list was a bare array, so every reader re-walked it: "which frond owns this
- * entity" was spelled four times, "every entity by name" three times as three literal
- * copies of the same `Map`, and the two inside the boot even carried comments saying so.
- * A concept nobody can question is a concept everyone rebuilds.
- *
- * It IS an array — the same reason `ListResult` is one: twenty call sites iterate,
- * filter and spread it, and none of them is wrong to. `Symbol.species` is `Array` so a
- * `.map()` over it answers a plain array rather than something that claims to be a
- * hosting table and holds strings.
- */
+/** What this app hosts, with the questions everyone was asking it by hand. */
 export class Fronds extends Array<FrondDescriptor> {
   static override get [Symbol.species](): ArrayConstructor {
     return Array;
@@ -21,9 +9,9 @@ export class Fronds extends Array<FrondDescriptor> {
 
   /** The fronds an app hosts, scanned or stated. The only gate in — `Array.of` is taken. */
   static hosting(fronds: readonly FrondDescriptor[]): Fronds {
-    const held = new Fronds();
-    held.push(...fronds);
-    return held;
+    const all = new Fronds();
+    all.push(...fronds);
+    return all;
   }
 
   /** The frond that hosts an entity — `undefined` when no loaded frond does. */
@@ -40,13 +28,7 @@ export class Fronds extends Array<FrondDescriptor> {
     return undefined;
   }
 
-  /**
-   * Every entity class, by name — across all fronds and never per-frond.
-   *
-   * A fact is announced in one frond and heard in another, so the subscriber's own
-   * frond does not hold the shape it must judge; a `reads:` clause names entities
-   * that belong to neighbours by definition.
-   */
+  /** Every entity class, by name — across all fronds and never per-frond. */
   schemas(): Map<string, SchemaView> {
     return new Map(this.flatMap((frond) => frond.entities.map((e) => [e.name, e.entityClass] as const)));
   }
@@ -56,14 +38,7 @@ export class Fronds extends Array<FrondDescriptor> {
     return this.flatMap((frond) => frond.entities.map((e) => e.name)).sort();
   }
 
-  /**
-   * The names a call may address, sorted — what a NOT_FOUND must print.
-   *
-   * Not `entityNames()`, which is what the scan found: an entity with no handler is
-   * scanned and serves nothing, so the refusal read *"Entity 'indexed' is not hosted
-   * here. Hosted here: indexed."* — naming the very thing it had just refused. A façade
-   * is keyed on a HANDLER's address, and that is what this lists.
-   */
+  /** The names a call may address, sorted — what a NOT_FOUND must print. */
   servedNames(surface?: string): string[] {
     return this.flatMap((frond) => frond.handlers
       .filter((handler) => (handler.surface ?? undefined) === surface)

package/src/descriptor/frond.ts

@@ -1,33 +1,12 @@
-/**
- * What a frond is made of — one interface per convention directory.
- *
- * Produced two ways and indistinguishable once here: the scan DERIVES it from a
- * directory tree, `frond()` STATES it outright. `frond-config.ts` is the declared
- * side; they meet at `FrondDescriptor.operationsOverrides`.
- */
+/** What a frond is made of — one interface per convention directory. */
 import type { SchemaView } from '@fougere/schema';
 import type { Param, OperationContract, OperationsMap } from '../wire/operation.js';
 import type { PresenterViews } from '../prefab/presenter.js';
 import type { Fronds } from './Fronds.js';
 
-/**
- * A discovered provider — a class under `services/` or `repositories/`, injected by type.
- *
- * Which of the two directories it came from is deliberately not recorded. The scan used
- * to tag it `kind: 'service' | 'repository'`, a field it filled on every provider and
- * that **no consumer ever read** — the two directories are two spellings of the same
- * thing, and DI resolves by type either way.
- */
+/** A discovered provider — a class under `services/` or `repositories/`, injected by type. */
 export interface ProviderEntry {
-  /**
-   * The class constructor (default export of the file).
-   *
-   * `never[]` and not `unknown[]`: the arguments are the CONTAINER's to supply, so the
-   * slot must accept any constructor — and with `unknown[]` a real class is refused,
-   * because assigning it would need `unknown` to be one of its declared parameters.
-   * Invisible on the scan path, where the value arrives as `unknown` and is cast; the
-   * module `fougere build` writes states the class by name, and that is where it showed.
-   */
+  /** The class constructor (default export of the file). */
   ctor: new (...args: never[]) => unknown;
   /** Constructor dependency type names (from AST scan). */
   deps: string[];
@@ -52,16 +31,8 @@ export interface HandlerEntry {
   /** Registration key (e.g. 'postHandler'). */
   name: string;
   /**
-   * The name this handler answers to — its class name minus `Handler`, lowercased
-   * (`PostHandler` → `post`). It is what `facadeKeyOf` builds its key from and what
-   * travels as `FrondCall.entity` on the wire.
-   *
-   * **It is NOT an entity name**, and it was called `entityName` for long enough to
-   * mislead: `toEntityName` (`scanner.ts`) strips the suffix without checking that any
-   * entity carries the result, and the boot states the consequence — *pointing at
-   * nothing is legal*. A health check, a search across several shapes, a pure
-   * computation: ordinary handlers that own no row. `PresenterEntry`/`CollectorEntry`
-   * keep `entityName` because those really do target a declared entity.
+   * The name this handler answers to — its class name minus `Handler`, lowercased (`PostHandler` →
+   * `post`).
    */
   address: string;
   /** The handler class. */
@@ -85,25 +56,11 @@ export interface PresenterFieldMeta {
   name: string;
   /** Inferred return type name: 'string', 'number', 'boolean', or a class name. */
   returnType?: string;
-  /**
-   * The field emits a LIST per row — `tags(posts: Post[]): string[][]`.
-   *
-   * The method answers one value per row, so the outer array level of its return type is
-   * the page, not the field: what remains after removing it is the field's own arity.
-   * Nothing measured that remainder, so a computed list and a computed scalar looked
-   * identical and every projection announced the scalar.
-   */
+  /** The field emits a LIST per row — `tags(posts: Post[]): string[][]`. */
   list?: boolean;
   /** Whether the return is nullable. */
   nullable?: boolean;
-  /**
-   * The declared parameters AFTER the rows. Kept raw rather than resolved: the scan
-   * meets presenters before collectors, so the plan is computed at boot where the
-   * collector names are known — exactly as a handler op's is.
-   *
-   * A computed field that declares `user?: User` is then fed by the collector
-   * that resolves one. A presenter is not a second mechanism.
-   */
+  /** The declared parameters AFTER the rows. */
   params?: Param[];
 }
 
@@ -118,10 +75,8 @@ export interface PresenterEntry {
   /** Per-field type metadata (inferred from source via parser). */
   fieldMeta: PresenterFieldMeta[];
   /**
-   * The view each computed field emits, when the presenter declares one
-   * (`Presenter(Order, { items: [OrderItemView] })`). Stated rather than inferred: the
-   * parser reads a scalar off a return type and nothing more, so an object-valued field
-   * has no derivable shape without this.
+   * The view each computed field emits, when the presenter declares one (`Presenter(Order, {
+   * items: [OrderItemView] })`).
    */
   views?: PresenterViews;
   /** Constructor dependency type names (from AST scan). */
@@ -172,18 +127,14 @@ export interface FrondDescriptor {
   presenters: PresenterEntry[];
   collectors: CollectorEntry[];
   seeds: SeedEntry[];
-  /** Per-surface entity lists from frond.config.ts (e.g. { graphql: ['Post'], rest: ['Post', 'Author'] }). */
+  /**
+   * Per-surface entity lists from frond.config.ts (e.g. { graphql: ['Post'], rest: ['Post',
+   * 'Author'] }).
+   */
   surfaces?: Record<string, string[]>;
   /** Entities this frond may read across sources — see `FrondConfig.reads`. */
   reads?: string[];
-  /**
-   * Per-operation overrides from frond.config.ts. Key = operation name.
-   *
-   * Two depths, as declared on {@link OperationOverride}: the surface keys travel to the
-   * transport adapters, the contract keys (`input`/`output`/`binding`) travel to the
-   * façade — where config is the third producer of an operation's contract, alongside a
-   * prefab's `__ops` and the scan.
-   */
+  /** Per-operation overrides from frond.config.ts. */
   operationsOverrides?: Record<string, OperationContract & {
     kind?: 'query' | 'command';
     /** Class name to resolve from DI (overrides default `{Entity}Handler` lookup). */

package/src/dispatch/ArgumentResolver.ts

@@ -1,4 +1,4 @@
-import type { InvocationContext } from '../contract/Invocation.js';
+import type { InvocationContext } from '../wire/Invocation.js';
 import type { BindingPlan } from '../wire/binding.js';
 
 export interface CollectorResolver {
@@ -40,15 +40,15 @@ export class ArgumentResolver {
         }
         case 'fact': {
           // A fact IS the payload — the whole of what happened, never a piece of it.
-          // Identical to `body` today, and deliberately not sharing its branch: the two
-          // agree by coincidence, not by rule, and the day `body` learns to look up a
+          // Identical to `input` today, and deliberately not sharing its branch: the two
+          // agree by coincidence, not by rule, and the day `input` learns to look up a
           // value by parameter name a subscriber would receive ONE FIELD of the fact it
           // subscribed to. Splitting it costs nothing and removes that trap.
-          args.push(ctx.body);
+          args.push(ctx.input);
           break;
         }
-        case 'body': {
-          args.push(ctx.body);
+        case 'input': {
+          args.push(ctx.input);
           break;
         }
         case 'query': {

package/src/dispatch/DispatchEvent.ts

@@ -1,5 +1,5 @@
-import type { Call } from '../contract/Call.js';
-import type { RouteKind } from '../contract/RouteAddress.js';
+import type { Call } from '../wire/call.js';
+import type { RouteKind } from '../wire/RouteAddress.js';
 
 export type DispatchStage = 'received' | 'resolved' | 'completed' | 'failed' | 'settled';
 

package/src/dispatch/DispatchLifecycle.ts

@@ -11,13 +11,7 @@ export class DispatchLifecycle {
     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*.
-   */
+  /** Subscribe after the dispatcher was built, and get the unsubscription back. */
   add(observer: DispatchObserver): () => void {
     this.observers.push(observer);
 

package/src/dispatch/DispatchPort.ts

@@ -1,4 +1,4 @@
-import type { Call } from '../contract/Call.js';
+import type { Call } from '../wire/call.js';
 
 /** The only capability an entry needs. */
 export interface DispatchPort {

package/src/dispatch/Dispatcher.ts

@@ -1,11 +1,11 @@
-import type { Call } from '../contract/Call.js';
+import type { Call } from '../wire/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 { routeNotFound, servedOperations } from './routeNotFound.js';
 import type { InFlight } from './InFlight.js';
 
 /** Resolves and executes every call through the same transverse lifecycle. */
@@ -29,7 +29,7 @@ export class Dispatcher implements DispatchPort {
       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);
+          ?? routeNotFound(call, servedOperations(call, this.routes.routes(), this.policy));
       }
 
       this.lifecycle.publish(DispatchEvent.resolved(call, route.kind));