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

package/src/boot/install.ts

@@ -28,7 +28,7 @@ import { targetOf } from '../prefab/prefab.js';
 import { ownersOf, sharedNames, storageInUserCode, crudOnOwned } from './ownership.js';
 import { refuseArityDrift } from './arity.js';
 import { StorageGuard } from '../dispatch/StorageGuard.js';
-import { portBindings, seamChains, wrapping, SEAMS } from './ports.js';
+import { heldKeyOf, portBindings, seamChains, wrapping, SEAMS } from './ports.js';
 import { contractsKeyOf, facadeKeyOf } from '../wire/Facade.js';
 import { inheritsCrud, subjectOf } from '../prefab/CrudConstructor.js';
 import { repositoryKeyOf } from '../prefab/RepositoryConstructor.js';
@@ -77,7 +77,7 @@ export interface Assembly {
   frondOf: Map<string, string>;
   contractsOf: (operations: EffectiveOperationsMap) => OperationsMap;
   /** Read at call time and never at boot, so a late registration still applies. */
-  getMiddlewares: (entity: string) => AppMiddleware[];
+  getMiddlewares: (address: string) => AppMiddleware[];
   /** Take a middleware on — every entity when no entity is named. */
   use: (middleware: AppMiddleware, entity?: string) => void;
   /**
@@ -310,17 +310,23 @@ function registerProviders(
     // Registered from the INSIDE OUT, each wrapper asking for the one it stands in front
     // of: the container resolves a dep by NAME, so wrapping is a substituted key and
     // needs nothing of the container itself. The outermost answers under the port.
-    let inner = nameOf(chain.at(-1)!);
-    for (const wrapper of chain.slice(0, -1).reverse()) {
+    const realization = chain.at(-1)!;
+    const held = realization.deps.includes(port);
+    const wrappers = held ? chain : chain.slice(0, -1);
+    let inner = held ? heldKeyOf(port) : nameOf(realization);
+    if (held) scope.registerValue(inner, scope.resolve(port));
+    for (const wrapper of wrappers.slice(1).reverse()) {
       const deps = ownLogger(nameOf(wrapper), wrapper.deps).map((dep) => (dep === port ? inner : dep));
       inner = nameOf(wrapper);
       scope.register(inner, wrapper.ctor, { deps, ...lifetimeOf(wrapper.ctor) });
     }
     const outermost = chain[0]!;
-    scope.register(port, outermost.ctor, {
-      deps: ownLogger(nameOf(outermost), outermost.deps).map((dep) => (dep === port ? nameOf(chain[1]!) : dep)),
+    const outermostOptions = {
+      deps: ownLogger(nameOf(outermost), outermost.deps).map((dep) => (dep === port ? inner : dep)),
       ...lifetimeOf(outermost.ctor),
-    });
+    };
+    if (wrappers.length > 0) scope.register(nameOf(outermost), outermost.ctor, outermostOptions);
+    scope.register(port, outermost.ctor, outermostOptions);
     boundPorts.add(port);
     frondLog.debug(`port ${port} → ${chain.map((one) => one.ctor.name).join(' → ')}`);
   }
@@ -445,7 +451,7 @@ function buildFacadeInto(
       routeRegistry.register(new OperationRoute(
         'local',
         new RouteAddress({
-          entity: handler.address,
+          address: handler.address,
           operation,
           ...(surface !== undefined ? { surface } : {}),
         }),

package/src/boot/peerOver.ts

@@ -1,12 +1,12 @@
 /** The two readings core serves everywhere, asked of one process over one transport. */
 import { Invocation } from '../wire/Invocation.js';
-import { RPC_ENTITY } from '../wire/RpcAnswer.js';
+import { RPC_ADDRESS } from '../wire/RpcAnswer.js';
 import type { Transport } from '../wire/Transport.js';
 import type { Peer } from './Peer.js';
 
 export function peerOver(transport: Transport): Peer {
   const ask = (op: string, params: Record<string, unknown>) =>
-    transport({ entity: RPC_ENTITY, op }, { ...Invocation.empty, params: params as never });
+    transport({ address: RPC_ADDRESS, op }, { ...Invocation.empty, params: params as never });
 
   return {
     missing: async (entity, keys) =>

package/src/boot/ports.ts

@@ -20,6 +20,9 @@ import type { Diagnostic } from '../diagnostic.js';
  */
 export const SEAMS = new Set(['Storage']);
 
+/** Where a chain of wrappers finds what the scope already answered under its port — a builtin's own instance. */
+export const heldKeyOf = (port: string): string => `held:${port}`;
+
 /**
  * What stands in front of each seam, outermost first — the same reading `portBindings`
  * does, with no realization to find.

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/builtin/Logger.ts

@@ -119,6 +119,16 @@ export class Logger {
 const objectOf = (arg: unknown): object =>
   typeof arg === 'object' && arg !== null && !Array.isArray(arg) ? arg : { value: arg };
 
+/**
+ * The operation as the line's writer sees it: bare when the writer is the class that runs it —
+ * `app:blog:PostHandler (publish)` — and whole when a service writes during another's.
+ */
+function operationSeenFrom(name: string, during: string): string {
+  const dot = during.lastIndexOf('.');
+
+  return name.endsWith(`:${during.slice(0, dot)}`) ? during.slice(dot + 1) : during;
+}
+
 export function formatted(
   record: Rendered,
   color = supportsColor(),
@@ -126,7 +136,7 @@ export function formatted(
   const style = LEVEL_STYLE[record.level];
   const time = stamp(record.at);
   const method = record.level;
-  const during = record.during ? ` (${record.during})` : '';
+  const during = record.during ? ` (${operationSeenFrom(record.name, record.during)})` : '';
 
   if (color) {
     const c = COLORS[style.color];

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);
   }
 }