@fougere/core 0.16.8-alpha.0 → 0.17.0-alpha.0

package/src/boot/remote.ts

@@ -6,7 +6,7 @@
 import type { FrondCall } from '../wire/FrondCall.js';
 import type { StateShape } from '../wire/StateShape.js';
 import type { Transport } from '../wire/Transport.js';
-import { RPC_ENTITY } from '../wire/RpcAnswer.js';
+import { RPC_ADDRESS } from '../wire/RpcAnswer.js';
 import { assertIdentityCard } from '../wire/card/IdentityCard.js';
 import { runMiddlewares, type AppMiddleware } from '../wire/AppMiddleware.js';
 import { type OperationContext } from '../wire/OperationContext.js';
@@ -14,7 +14,7 @@ import { Invocation } from '../wire/Invocation.js';
 import { type InvocationContext } from '../wire/InvocationContext.js';
 import { ErrorCode } from '../wire/ErrorCode.js';
 import { FougereError } from '../wire/FougereError.js';
-import { Card, type SchemaView, type SchemaDescriptor } from '@fougere/schema';
+import { Card, type SchemaView } from '@fougere/schema';
 import { dynamicOperations } from '../entry/facade.js';
 import { decoded } from '../dispatch/decoded.js';
 
@@ -22,23 +22,26 @@ interface Route {
   frond: string;
   transport: Transport;
   /**
-   * The entity's schema, rebuilt from the identity card — the same `SchemaConstructor` shape
-   * `entity({...})` produces, live validation included.
+   * What each operation answers, rebuilt from the identity card — the same `SchemaConstructor`
+   * shape `entity({...})` produces, live validation included.
    */
-  schema?: SchemaView;
+  outputs: Map<string, SchemaView>;
 }
 
 export interface RemoteRouter {
-  route(entity: string): Promise<Route>;
+  route(address: string): Promise<Route>;
+  /** The schema a remote STORES under an entity's name — `undefined` when none does. */
+  schemaOf(entity: string): Promise<SchemaView | undefined>;
 }
 
 export function createRemoteRouter(
   remotes: Record<string, string>,
   makeTransport: (url: string) => Transport,
 ): RemoteRouter {
-  const byEntity = new Map<string, Route>();
+  const byAddress = new Map<string, Route>();
+  const stored = new Map<string, SchemaView>();
   // The remotes config key is a label for the address — the identity card is
-  // what decides which entities live behind it.
+  // what decides which addresses answer behind it.
   const pending = new Map(Object.entries(remotes));
   const transports = new Map<string, Transport>();
 
@@ -54,7 +57,7 @@ export function createRemoteRouter(
         const transport = transports.get(url) ?? makeTransport(url);
         transports.set(url, transport);
         try {
-          const answer = await transport({ entity: RPC_ENTITY, op: 'discover' }, Invocation.empty);
+          const answer = await transport({ address: RPC_ADDRESS, op: 'discover' }, Invocation.empty);
 
           // Judged below and not here: this catch means "unreachable, retry", and a
           // refusal thrown inside it would be swallowed into another silent retry.
@@ -70,28 +73,34 @@ export function createRemoteRouter(
       if (!answered) continue;
 
       pending.delete(answered.label);
-      claimFacades(answered, byEntity, claimedBy);
+      claimFacades(answered, byAddress, claimedBy);
+      storedBy(answered, stored);
     }
   };
 
   return {
-    async route(entity) {
-      if (!byEntity.has(entity) && pending.size > 0) await discover();
-      const hit = byEntity.get(entity);
+    async schemaOf(entity) {
+      if (!stored.has(entity) && pending.size > 0) await discover();
+
+      return stored.get(entity);
+    },
+    async route(address) {
+      if (!byAddress.has(address) && pending.size > 0) await discover();
+      const hit = byAddress.get(address);
       if (hit) return hit;
       if (pending.size > 0) {
         throw new FougereError({
           code: ErrorCode.SERVICE_UNAVAILABLE,
-          message: `No reachable remote hosts '${entity}' — unreachable: ${[...pending.keys()].join(', ')}.\n`
+          message: `No reachable remote serves '${address}' — unreachable: ${[...pending.keys()].join(', ')}.\n`
           + '  Named in `remotes:`, and did not answer.',
-          entity,
+          address,
         });
       }
       throw new FougereError({
         code: ErrorCode.NOT_FOUND,
-        message: `No declared remote hosts '${entity}'.\n`
+        message: `No declared remote serves '${address}'.\n`
           + '  Nothing here serves it either — add its frond to `fronds:`/`scan:`, or name the frond that does in `remotes:`.',
-        entity,
+        address,
       });
     },
   };
@@ -101,28 +110,27 @@ type Facade = Record<string, (invocation?: InvocationContext) => Promise<unknown
 
 /** Façade-shaped stand-in — the consumer can't tell it from a local facade. */
 export function createRemoteFacade(
-  entity: string,
+  address: string,
   router: RemoteRouter,
   middlewaresFor: (address: string) => AppMiddleware[],
   shape: StateShape,
 ): Facade {
   const opFn = (op: string) => async (received: InvocationContext = Invocation.empty) => {
-    const { frond, transport, schema } = await router.route(entity);
-    const call: FrondCall = { frond, entity, op };
-    const state = received.crossed ? { ...received.state } : shape.judge(received.state, entity, op);
+    const { frond, transport, outputs } = await router.route(address);
+    const call: FrondCall = { frond, address, op };
+    const state = received.crossed ? { ...received.state } : shape.judge(received.state, address, op);
     const invocation = { ...received, state };
     const entered = { ...state };
     const ctx: OperationContext = {
-      entity, frond, operation: op, args: [], state, invocation, crosses: true,
+      address, frond, operation: op, args: [], state, invocation, crosses: true,
     };
-    const answer = await runMiddlewares(middlewaresFor(entity), ctx, () =>
-      transport(call, { ...(ctx.invocation ?? invocation), state: shape.judge(ctx.state, entity, op, entered) }));
-
-    // The schema the card carried, put to work: a row crosses as data and comes back through
-    // the same codecs a local facade applies, so a placement does not decide what a caller
-    // holds. It is the ENTITY's — an op serving a narrower view is the far side's business,
-    // and what this card names is the shape it publishes.
-    return decoded(schema, answer);
+    const answer = await runMiddlewares(middlewaresFor(address), ctx, () =>
+      transport(call, { ...(ctx.invocation ?? invocation), state: shape.judge(ctx.state, address, op, entered) }))
+      .catch((error: unknown) => { throw error instanceof FougereError ? error.at(address, op) : error; });
+
+    // What the op says it answers, put to work: a row crosses as data and comes back through
+    // the same codecs a local facade applies, so a placement does not decide what a caller holds.
+    return decoded(outputs.get(op), answer);
   };
 
   return dynamicOperations(opFn) as Facade;
@@ -143,7 +151,7 @@ interface Answered {
  */
 function claimFacades(
   { label, url, transport, answer }: Answered,
-  byEntity: Map<string, Route>,
+  byAddress: Map<string, Route>,
   claimedBy: Map<string, string>,
 ): void {
   const card = assertIdentityCard(answer, `Remote '${label}' (${url})`);
@@ -156,19 +164,27 @@ function claimFacades(
           code: ErrorCode.INTERNAL_ERROR,
           message:
             `[claim] Two remotes serve '${facade.name}': '${first}' and '${label}'.\n`
-            + `  A call names an entity, not a frond, so nothing could choose between them.\n`
+            + `  A call names an address, not a frond, so nothing could choose between them.\n`
             + `  - Keep one of the two out of \`remotes:\`, or\n`
-            + `  - expose one of them under a different entity name.`,
-          entity: facade.name,
+            + `  - expose one of them under a different address.`,
+          address: facade.name,
         });
       }
 
       claimedBy.set(facade.name, label);
-      byEntity.set(facade.name, {
+      byAddress.set(facade.name, {
         frond: frond.name,
         transport,
-        ...(facade.schema ? { schema: Card.fromDescriptor(facade.schema as SchemaDescriptor).toSchema() } : {}),
+        outputs: new Map(facade.ops.flatMap((op) =>
+          op.output ? [[op.name, Card.fromDescriptor(op.output).toSchema()] as const] : [])),
       });
     }
   }
 }
+
+/** What each remote stores, by entity name — what `schemaFor` answers for a row kept elsewhere. */
+function storedBy({ label, url, answer }: Answered, stored: Map<string, SchemaView>): void {
+  for (const frond of assertIdentityCard(answer, `Remote '${label}' (${url})`).fronds) {
+    for (const entity of frond.entities) stored.set(entity.name, Card.fromDescriptor(entity.schema).toSchema());
+  }
+}

package/src/contract.ts

@@ -27,7 +27,7 @@ export type { Transport } from './wire/Transport.js';
 export { ENVELOPE_BYTES, maxBodyBytes, maxFrameBytes, setMaxBodyBytes } from './wire/BodyLimit.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/RpcAnswer.js';
+export { RPC_ADDRESS } from './wire/RpcAnswer.js';
 export type { CallPage } from './wire/CallPage.js';
 export { pageOf, asPage, type Page } from './wire/Page.js';
 export type { CallRecord } from './wire/CallRecord.js';
@@ -69,7 +69,7 @@ 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).
+ * })` (class + verb) or `callValueOf({ address, op }, input)` (raw, for dynamic bridges).
  */
 export function callValueOf(
   target: { name: string } | FrondCall,
@@ -78,7 +78,7 @@ export function callValueOf(
 ): CallValue {
   const [call, given] =
     typeof opOrInput === 'string'
-      ? [{ entity: lowerFirst((target as { name: string }).name), op: opOrInput }, input]
+      ? [{ address: lowerFirst((target as { name: string }).name), op: opOrInput }, input]
       : [target as FrondCall, opOrInput];
 
   return { call, invocation: Invocation.from(given) };

package/src/descriptor/ProviderEntry.ts

@@ -15,4 +15,9 @@ export interface ProviderEntry {
   deps: string[];
   /** Absolute file path (for debugging). */
   filePath: string;
+  /**
+   * What the source said and the runtime erased: a port, which a class below answers for and
+   * nothing may instantiate — never a candidate for the ports above it.
+   */
+  abstract?: true;
 }

package/src/descriptor/bases.ts

@@ -1,13 +1,19 @@
 import { type ProviderEntry } from './ProviderEntry.js';
 
 /**
- * Port class name → the classes that extend it, in scan order.
+ * Port class name → every concrete class below it, in scan order.
  *
  * ONE condition, and the caller owns it: something already answers under that name. The boot
  * asks its container, where the providers sit in the frond's scope and the builtins in its
  * parent — so a neighbour service and `Logger` both count, a framework class being a port like
  * any other, which is what makes a default overridable.
  *
+ * A provider is ranked under the highest ancestor that answers AND under every class it crossed
+ * to reach it: a class something extends is a port, declared or not. `StripePayment extends
+ * CardPayment extends Payment` answers both, so an abstract `CardPayment` nobody registers is
+ * still a key, and a DECLARED abstract one is never a candidate. A wrapper stops at the class it asks for — it stands in front of that one and
+ * realizes nothing above it.
+ *
  * It is also what excludes a prefab: a repository extends the class `Repository(Post)`
  * returned (`RepositoryBase`), and no key is ever that name.
  *
@@ -20,11 +26,21 @@ export function basesOf(
 ): Map<string, ProviderEntry[]> {
   const bases = new Map<string, ProviderEntry[]>();
   for (const provider of providers) {
-    const base = Object.getPrototypeOf(provider.ctor) as { name?: string } | null;
-    const port = base?.name;
-    if (!port || !answers(port)) continue;
-    bases.set(port, [...(bases.get(port) ?? []), provider]);
+    if (provider.abstract) continue;
+    for (const port of portsOf(provider, answers)) bases.set(port, [...(bases.get(port) ?? []), provider]);
   }
 
   return bases;
 }
+
+/** The ancestors a provider answers under, nearest first, up to the last one that answers. */
+function portsOf(provider: ProviderEntry, answers: (name: string) => boolean): string[] {
+  const crossed: string[] = [];
+  for (let base = Object.getPrototypeOf(provider.ctor) as { name?: string } | null; base?.name; base = Object.getPrototypeOf(base) as { name?: string } | null) {
+    if (provider.deps.includes(base.name)) return [base.name];
+    crossed.push(base.name);
+  }
+  const last = crossed.findLastIndex(answers);
+
+  return crossed.slice(0, last + 1);
+}

package/src/dispatch/ArgumentResolver.ts

@@ -1,8 +1,12 @@
 import type { InvocationContext } from '../wire/InvocationContext.js';
 import type { BindingPlan } from '../wire/binding.js';
+import { ErrorCode } from '../wire/ErrorCode.js';
+import { FougereError } from '../wire/FougereError.js';
 import type { CollectorLookup } from './CollectorLookup.js';
 import { collectedAs } from '../prefab/collector.js';
 
+type ParamSource = Extract<BindingPlan[number]['source'], { kind: 'param' }>;
+
 /** Resolves an operation's declared binding plan against one invocation. */
 export class ArgumentResolver {
   constructor(private readonly collectors?: CollectorLookup) {}
@@ -22,16 +26,7 @@ export class ArgumentResolver {
           break;
         }
         case 'param': {
-          // `null` is a value, not a miss. Nullish coalescing used to make an explicit
-          // nullable path/GraphQL argument fall through to query (or become undefined),
-          // collapsing `T | null` into `T | undefined`. Only undefined means absent.
-          const fromParams = ctx.params[binding.source.name];
-          let val: unknown = fromParams === undefined
-            ? ctx.query[binding.source.name]
-            : fromParams;
-          if (val != null && binding.source.coerce === 'number') val = Number(val);
-          if (val != null && binding.source.coerce === 'boolean') val = val === 'true' || val === '1' || val === true;
-          args.push(val);
+          args.push(ArgumentResolver.param(binding.source, binding.optional, ctx));
           break;
         }
         case 'fact':
@@ -60,4 +55,48 @@ export class ArgumentResolver {
 
     return args;
   }
+
+  /**
+   * A value the caller typed in a path or a query string. `null` is a value, not a miss: only
+   * `undefined` means absent, so `T | null` stays apart from `T | undefined`.
+   */
+  private static param(source: ParamSource, optional: boolean, ctx: InvocationContext): unknown {
+    const { name, coerce } = source;
+    const fromParams = ctx.params[name];
+    const value: unknown = fromParams === undefined ? ctx.query[name] : fromParams;
+
+    if (value === undefined) {
+      if (optional) return undefined;
+      throw refused(name, 'Required');
+    }
+    if (value === null || coerce === undefined) return value;
+
+    const coerced = coerce === 'number' ? ArgumentResolver.number(value) : ArgumentResolver.boolean(value);
+    if (coerced === undefined) throw refused(name, `Expected a ${coerce}, got ${JSON.stringify(value)}`);
+
+    return coerced;
+  }
+
+  private static number(value: unknown): number | undefined {
+    if (typeof value === 'number') return Number.isNaN(value) ? undefined : value;
+    if (typeof value !== 'string' || value.trim() === '') return undefined;
+    const parsed = Number(value);
+
+    return Number.isNaN(parsed) ? undefined : parsed;
+  }
+
+  private static boolean(value: unknown): boolean | undefined {
+    if (value === true || value === 'true' || value === '1') return true;
+    if (value === false || value === 'false' || value === '0') return false;
+
+    return undefined;
+  }
+}
+
+function refused(name: string, message: string): FougereError {
+  return new FougereError({
+    code: ErrorCode.VALIDATION_FAILED,
+    message: `${name}: ${message}`,
+    details: [{ path: [name], message }],
+  });
 }

package/src/dispatch/Dispatcher.ts

@@ -65,7 +65,7 @@ export class Dispatcher implements DispatchPort {
     this.lifecycle.publish(DispatchEvent.received(call));
 
     try {
-      release = this.inFlight.enter(call.address.entity, call.address.operation);
+      release = this.inFlight.enter(call.address.address, call.address.operation);
       route = await this.routeFor(call);
 
       this.lifecycle.publish(DispatchEvent.resolved(call, route.kind));

package/src/dispatch/HandlerFacade.ts

@@ -21,6 +21,7 @@ import { OutputView } from './OutputView.js';
 import { PresenterExecutor } from './PresenterExecutor.js';
 import { presenterArguments, presenterPlans } from './presenterArguments.js';
 import { validateInput } from './validateInput.js';
+import { FougereError } from '../wire/FougereError.js';
 import type { Facade } from './Facade.js';
 
 /** Adapts one handler facade to executable operations. */
@@ -79,22 +80,22 @@ export class HandlerFacade {
 
   /** One operation, through the same ordered boundary steps on every route. */
   async execute(op: string, input?: Partial<InvocationContext>): Promise<unknown> {
-    const entity = this.handler.address;
+    const address = this.handler.address;
     const contract = this.contracts.get(op);
     if (!contract) {
       throw new Error(
-        `${entity} serves no operation '${op}'. `
+        `${address} serves no operation '${op}'. `
         + `It serves ${[...this.contracts.keys()].join(', ')}.`,
       );
     }
 
     const received = Invocation.from(input);
-    const state = received.crossed ? { ...received.state } : this.facade.state.judge(received.state, entity, op);
+    const state = received.crossed ? { ...received.state } : this.facade.state.judge(received.state, address, op);
     const invocation = received.withState(state);
     const entered = { ...state };
     const { className, method } = this.effectiveOperations.get(op)!.implementation;
     const context: OperationContext = {
-      entity,
+      address,
       frond: this.facade.frond,
       handler: className,
       operation: op,
@@ -106,7 +107,8 @@ export class HandlerFacade {
     const label = `${this.facade.frond}:${className}.${method}`;
 
     return runMiddlewares(this.facade.middlewares(), context, () =>
-      this.facade.enterOperation(label, () => this.answer(op, contract, context, invocation, entered)));
+      this.facade.enterOperation(label, () => this.answer(op, contract, context, invocation, entered)))
+      .catch((error: unknown) => { throw error instanceof FougereError ? error.at(address, op) : error; });
   }
 
   /**
@@ -121,7 +123,7 @@ export class HandlerFacade {
     entered: Record<string, unknown>,
   ): Promise<unknown> {
     const state = this.facade.state.judge(context.state, this.handler.address, op, entered);
-    const validated = validateInput(contract.input, { ...invocation, state }, this.handler.address, op);
+    const validated = validateInput(contract.input, { ...invocation, state });
     context.invocation = validated;
 
     const args = contract.binding ? await this.arguments.resolve(contract.binding, validated) : [];
@@ -149,12 +151,9 @@ export class HandlerFacade {
     output: unknown,
     invocation: InvocationContext,
   ): Promise<unknown> {
-    const entity = this.handler.address;
     const executor = new PresenterExecutor(
-      this.facade.presenterScope.resolve(presenterKeyOf(entity)),
+      this.facade.presenterScope.resolve(presenterKeyOf(this.handler.address)),
       presenter.fields,
-      entity,
-      op,
     );
 
     return presenterArguments(this.presenterPlans, invocation, this.arguments)

package/src/dispatch/InFlight.ts

@@ -11,12 +11,12 @@ export class InFlight {
     return this.running;
   }
 
-  enter(entity: string, operation: string): () => void {
+  enter(address: string, operation: string): () => void {
     if (!this.accepting) {
       throw new FougereError({
         code: ErrorCode.SERVICE_UNAVAILABLE,
         message: 'This app is being released and takes no new call — reach the current one through its handle.',
-        entity,
+        address,
         operation,
       });
     }

package/src/dispatch/LocalRoutePolicy.ts

@@ -1,6 +1,7 @@
 import type { Call } from '../wire/Call.js';
 import { ErrorCode } from '../wire/ErrorCode.js';
 import { FougereError } from '../wire/FougereError.js';
+import { RPC_ADDRESS } from '../wire/RpcAnswer.js';
 import type { Route } from './Route.js';
 import type { RoutePolicy } from './RoutePolicy.js';
 import { routeNotFound, servedOperations } from './routeNotFound.js';
@@ -14,22 +15,21 @@ export class LocalRoutePolicy implements RoutePolicy {
   }
 
   notFound(call: Call, routes: readonly Route[]): Error | undefined {
-    if (call.address.entity === 'rpc') return undefined;
+    if (call.address.address === RPC_ADDRESS) return undefined;
 
     const served = servedOperations(call, routes, this);
     if (served.length > 0) return routeNotFound(call, served);
 
     const hosted = this.hostedNames(call.address.surface);
-    const entity = call.address.entity;
-    const surface = call.address.surface;
+    const { address, surface } = call.address;
 
     return new FougereError({
       code: ErrorCode.NOT_FOUND,
       message: (surface
-        ? `Entity '${entity}' is not served on surface '${surface}'`
-        : `Entity '${entity}' is not hosted here`)
-        + (hosted.length ? `. Hosted here: ${hosted.join(', ')}.` : '. This app hosts no entity.'),
-      entity,
+        ? `'${address}' is not served on surface '${surface}'`
+        : `Nothing here answers at '${address}'`)
+        + (hosted.length ? `. Served here: ${hosted.join(', ')}.` : '. This app serves no address.'),
+      address,
       operation: call.address.operation,
     });
   }

package/src/dispatch/PresenterExecutor.ts

@@ -9,8 +9,6 @@ export class PresenterExecutor {
   constructor(
     private readonly presenter: Record<string, unknown> | undefined,
     private readonly fieldNames: readonly string[] | undefined,
-    private readonly entity = 'unknown',
-    private readonly operation = 'unknown',
   ) {}
 
   async present(result: unknown, args: PresenterArgs = {}): Promise<unknown> {
@@ -64,8 +62,6 @@ export class PresenterExecutor {
       throw new FougereError({
         code: ErrorCode.INTERNAL_ERROR,
         message: `Computed field '${name}' failed: ${(cause as Error)?.message ?? cause}`,
-        entity: this.entity,
-        operation: this.operation,
         cause,
       });
     }

package/src/dispatch/Release.ts

@@ -131,8 +131,6 @@ async function refuseHeld(
     code: ErrorCode.CONFLICT,
     message: `${dependent.entity}.${dependent.field} holds ${found.length} row(s) naming this one, `
       + `and states onDelete 'restrict' — take them out first, or declare what should happen.`,
-    entity,
-    operation: 'delete',
   });
 }
 

package/src/dispatch/RouteRegistry.ts

@@ -32,7 +32,7 @@ export class RouteRegistry {
     if (exact || address.surface === undefined) return exact;
 
     const shared = this.byAddress.get(new RouteAddress({
-      entity: address.entity,
+      address: address.address,
       operation: address.operation,
     }).key());
 
@@ -69,9 +69,9 @@ export class RouteRegistry {
     return [...this.byAddress.values()];
   }
 
-  operationNames(entity: string, surface?: string): string[] {
+  operationNames(address: string, surface?: string): string[] {
     return this.routes()
-      .filter((route) => route.address.entity === entity && route.address.surface === surface)
+      .filter((route) => route.address.address === address && route.address.surface === surface)
       .map((route) => route.address.operation);
   }
 }

package/src/dispatch/StorageGuard.ts

@@ -154,9 +154,7 @@ export class StorageGuard {
     if (errors.length > 0) {
       throw new FougereError({
         code: ErrorCode.BAD_REQUEST,
-        message: `Refused as a filter — ${errors.join(', ')}`,
-        entity: this.entity,
-        operation: 'list',
+        message: `Refused as a filter on ${this.entity} — ${errors.join(', ')}`,
         details: errors,
       });
     }
@@ -247,9 +245,7 @@ export class StorageGuard {
     if (errors.length > 0) {
       throw new FougereError({
         code: ErrorCode.INTERNAL_ERROR,
-        message: `Refused on the way out — ${errors.join(', ')}`,
-        entity: this.entity,
-        operation,
+        message: `Refused on the way out of ${this.entity}.${operation} — ${errors.join(', ')}`,
         details: errors,
       });
     }
@@ -287,9 +283,7 @@ export class StorageGuard {
 
     throw new FougereError({
       code: ErrorCode.VALIDATION_FAILED,
-      message: `Refused on the way out — ${errors.join(', ')}`,
-      entity: this.entity,
-      operation,
+      message: `Refused on the way out of ${this.entity}.${operation} — ${errors.join(', ')}`,
       details: errors,
     });
   }

package/src/dispatch/remoteRoutes.ts

@@ -2,14 +2,14 @@ import { OperationRoute } from './OperationRoute.js';
 import type { RouteResolver } from './RouteResolver.js';
 
 type RemoteFacade = Record<string, Function>;
-export type RemoteFacadeResolver = (entity: string) => RemoteFacade | undefined;
+export type RemoteFacadeResolver = (address: string) => RemoteFacade | undefined;
 
 /** Builds a remote route on the first call, once the remote façade can be resolved. */
 export function remoteRoutes(facades: RemoteFacadeResolver): RouteResolver {
   return (address) => {
     if (address.surface !== undefined) return undefined;
 
-    const facade = facades(address.entity);
+    const facade = facades(address.address);
     const operation = facade?.[address.operation];
 
     if (typeof operation !== 'function') return undefined;

package/src/dispatch/routeNotFound.ts

@@ -1,6 +1,7 @@
 import type { Call } from '../wire/Call.js';
 import { ErrorCode } from '../wire/ErrorCode.js';
 import { FougereError } from '../wire/FougereError.js';
+import { RPC_ADDRESS } from '../wire/RpcAnswer.js';
 import type { Route } from './Route.js';
 import type { RoutePolicy } from './RoutePolicy.js';
 
@@ -12,7 +13,7 @@ export function servedOperations(
 ): readonly string[] {
   return routes
     .filter((route) => !policy || policy.accepts(route))
-    .filter((route) => route.address.entity === call.address.entity)
+    .filter((route) => route.address.address === call.address.address)
     .filter((route) => route.kind === 'system' || route.address.surface === call.address.surface)
     .map((route) => route.address.operation);
 }
@@ -22,13 +23,13 @@ export function routeNotFound(
   call: Call,
   served: readonly string[],
 ): FougereError {
-  const { entity, operation } = call.address;
-  const message = entity === 'rpc'
+  const { address, operation } = call.address;
+  const message = address === RPC_ADDRESS
     ? `Unknown rpc operation '${operation}'. `
       + (served.length ? `It serves ${served.join(', ')}.` : 'It serves nothing.')
     : served.length
-      ? `Unknown operation '${operation}' on '${entity}'. It serves ${served.join(', ')}.`
+      ? `Unknown operation '${operation}' on '${address}'. It serves ${served.join(', ')}.`
       : `No route serves '${call.address}'`;
 
-  return new FougereError({ code: ErrorCode.NOT_FOUND, message, entity, operation });
+  return new FougereError({ code: ErrorCode.NOT_FOUND, message, address, operation });
 }

package/src/dispatch/validateInput.ts

@@ -7,8 +7,6 @@ import { FougereError } from '../wire/FougereError.js';
 export function validateInput(
   schema: SchemaView | undefined,
   invocation: InvocationContext,
-  entity: string,
-  operation: string,
 ): InvocationContext {
   if (!schema || invocation.input === undefined || invocation.input === null) return invocation;
 
@@ -20,8 +18,6 @@ export function validateInput(
       code: ErrorCode.VALIDATION_FAILED,
       message: result.errors.map((error) => `${dotted(error.path)}: ${error.message}`).join(', '),
       details: result.errors,
-      entity,
-      operation,
     });
   }
 

package/src/entry/facade.ts

@@ -32,7 +32,7 @@ export function dynamicOperations(operation: (name: string) => Operation): Recor
  */
 export function facadeOperations(
   dispatcher: DispatchPort,
-  entity: string,
+  address: string,
   operationNames?: Iterable<string>,
   surface?: string,
   received?: Received,
@@ -40,7 +40,7 @@ export function facadeOperations(
   const operation = (name: string): Operation => async (invocation) => {
     const answer = await dispatcher.dispatch(new Call(
       new RouteAddress({
-        entity,
+        address,
         operation: name,
         ...(surface !== undefined ? { surface } : {}),
       }),