@fougere/core 0.9.3-alpha.0 → 0.10.0-alpha.0

package/src/boot/install.ts

@@ -1,27 +1,31 @@
 /** Putting one frond into the app being built: its scope, what it serves, what it takes. */
 import type { Container } from '@fougere/container';
 import { lowerFirst, type Fields, type SchemaView } from '@fougere/schema';
-import type { Logger } from '../builtin/logger.js';
+import type { Logger } from '../builtin/Logger.js';
 import type { Dispatcher } from '../dispatch/Dispatcher.js';
 import type { RouteRegistry } from '../dispatch/RouteRegistry.js';
 import type { Emissions } from './Emissions.js';
-import type { EffectiveOperationsMap, EffectiveOperationModel } from '../effective-operation.js';
-import { nameOf, type ProviderEntry } from '../descriptor/frond.js';
-import type { EntityEntry, FrondDescriptor, HandlerEntry } from '../descriptor/frond.js';
-import type { OperationsMap } from '../wire/operation.js';
-import type { AppMiddleware } from '../wire/middleware.js';
-import type { CreateAppOptions } from './types.js';
+import type { EffectiveOperationModel } from '../EffectiveOperationModel.js';
+import type { EffectiveOperationsMap } from '../EffectiveOperationsMap.js';
+import { nameOf } from '../descriptor/FrondDescriptor.js';
+import type { EntityEntry } from '../descriptor/EntityEntry.js';
+import type { FrondDescriptor } from '../descriptor/FrondDescriptor.js';
+import type { HandlerEntry } from '../descriptor/HandlerEntry.js';
+import type { OperationsMap } from '../wire/OperationsMap.js';
+import type { AppMiddleware } from '../wire/AppMiddleware.js';
+import type { CreateAppOptions } from './CreateAppOptions.js';
 import { registerFrames } from './together.js';
+import type { Diagnostic } from '../diagnostic.js';
 import { HandlerFacade } from '../dispatch/HandlerFacade.js';
 import { targetOf } from '../prefab/prefab.js';
-import { ownersOf, refuseSharedName, refuseStorageInUserCode, refuseCrudOnOwned } from './ownership.js';
+import { ownersOf, sharedNames, storageInUserCode, crudOnOwned } from './ownership.js';
 import { StorageGuard } from '../dispatch/StorageGuard.js';
 import { portBindings, seamChains, wrapping, SEAMS } from './ports.js';
-import { facadeKeyOf, contractsKeyOf } from '../wire/call.js';
-import { inheritsCrud, subjectOf } from '../prefab/crud.js';
-import { repositoryKeyOf } from '../prefab/repository.js';
-import { storageKeyOf } from '../storage/port.js';
-import { declares } from '../source.js';
+import { contractsKeyOf, facadeKeyOf } from '../wire/Facade.js';
+import { inheritsCrud, subjectOf } from '../prefab/CrudConstructor.js';
+import { repositoryKeyOf } from '../prefab/RepositoryConstructor.js';
+import { storageKeyOf } from '../storage/Storage.js';
+import { declares } from '../Source.js';
 import { presenterKeyOf } from '../prefab/presenter.js';
 import { collectorKeyOf } from '../prefab/collector.js';
 import { RouteAddress } from '../wire/RouteAddress.js';
@@ -39,12 +43,14 @@ export interface Assembly {
   routeRegistry: RouteRegistry;
   emissions: Emissions;
   dispatcher: Dispatcher;
-  /** A door under a named surface answers only what that surface serves. */
+  /** A facade under a named surface answers only what that surface serves. */
   localDispatcher: Dispatcher;
   /** Filled per façade key, read back by `operationsFor` and the identity card. */
   effectiveByKey: Map<string, EffectiveOperationsMap>;
   /** Every `ports:` key some frond actually settled — what is left is a typo. */
   boundPorts: Set<string>;
+  /** Where a check writes what does not hold — collected across fronds, refused together. */
+  refused: Diagnostic[];
   /** What the model resolved before the boot performed any side effect. */
   operationModel: EffectiveOperationModel;
   entityByName: Map<string, SchemaView>;
@@ -61,7 +67,7 @@ export interface Assembly {
 export async function installFrond(frond: FrondDescriptor, assembly: Assembly): Promise<void> {
   const {
     container, routeRegistry, emissions, dispatcher, localDispatcher, effectiveByKey,
-    boundPorts, operationModel, entityByName, frondOf, contractsOf, getMiddlewares, use,
+    boundPorts, refused, operationModel, entityByName, frondOf, contractsOf, getMiddlewares, use,
     log, options,
   } = assembly;
 
@@ -69,7 +75,7 @@ export async function installFrond(frond: FrondDescriptor, assembly: Assembly):
   // register nothing locally — resolve() falls through to the remote façade.
   if (options.remotes && frond.name in options.remotes) {
     log.child(frond.name).info('declared remote — not hosted locally');
-    // Its doors answer elsewhere, but what they LISTEN to was read here.
+    // Its facades answer elsewhere, but what they LISTEN to was read here.
     for (const handler of frond.handlers) {
       const key = facadeKeyOf(handler.address, handler.surface);
       const operations = operationModel.forHandler(handler);
@@ -99,7 +105,7 @@ export async function installFrond(frond: FrondDescriptor, assembly: Assembly):
   if (frond.reads?.length && options.sourcesFactory) {
     // Resolved across the WHOLE app, not this frond's own entities: a cross-source
     // query joins entities from different fronds by definition — `Progress` here,
-    // `Book` next door — so restricting the list to its own would make it useless.
+    // `Book` next facade — so restricting the list to its own would make it useless.
     // Naming one IS the authorization; that is what the declaration is for.
     const named = frond.reads
       .map((name) => entityByName.get(lowerFirst(name)))
@@ -117,10 +123,10 @@ export async function installFrond(frond: FrondDescriptor, assembly: Assembly):
 
   // Who owns what, and the rule that makes owning mean something. Before anything is
   // registered, so a bad line is named by this refusal rather than by the container's.
-  refuseSharedName(frond);
-  const owners = ownersOf(frond.providers);
-  refuseStorageInUserCode(frond, owners, (entity) => entityByName.has(entity));
-  refuseCrudOnOwned(frond, owners);
+  sharedNames(frond, refused);
+  const owners = ownersOf(frond.providers, frond.name, refused);
+  storageInUserCode(frond, owners, (entity) => entityByName.has(entity), refused);
+  crudOnOwned(frond, owners, refused);
 
   for (const provider of frond.providers) {
     scope.register(nameOf(provider), provider.ctor, { deps: provider.deps });
@@ -128,7 +134,7 @@ export async function installFrond(frond: FrondDescriptor, assembly: Assembly):
   // What this frond puts in front of one of the framework's own ports. Its own, like every
   // provider — a link goes where its frond goes, which is what a frond behind `remotes:`
   // takes with it.
-  const seams = seamChains(frond.providers, options.ports);
+  const seams = seamChains(frond.providers, options.ports, refused);
   for (const [seam, links] of seams) {
     boundPorts.add(seam);
     frondLog.debug(`seam ${seam} → ${links.map((one) => one.ctor.name).join(' → ')} → the realization`);
@@ -137,7 +143,10 @@ export async function installFrond(frond: FrondDescriptor, assembly: Assembly):
   // reaches the realization instead of the base class it is declared against.
   // Registered AFTER the loop above so a port key always wins over the base's
   // own registration — same precedence as a declared repository over its default.
-  for (const [port, chain] of portBindings(frond.providers, (n) => scope.has(n), options.ports)) {
+  for (const [port, chain] of portBindings(frond.providers, (n) => scope.has(n), options.ports, refused)) {
+    // A chain a refusal emptied — `ports:` named a class that extends nothing. Already
+    // reported, and there is no realization left to put a key in front of.
+    if (chain.length === 0) continue;
     // A seam is bound where its realization is BUILT, not under a container key — nothing
     // resolves `Storage`, and `<Entity>Storage` is what a handler asks for.
     if (SEAMS.has(port)) continue;
@@ -182,7 +191,7 @@ export async function installFrond(frond: FrondDescriptor, assembly: Assembly):
 
       // The declared chain first, then the guard OUTSIDE it: the guard hands on the value
       // it parsed, so a wrapper reads what the entity says a row is rather than what
-      // arrived. Same order the client door has held since `StorageGuard` existed.
+      // arrived. Same order the client facade has held since `StorageGuard` existed.
       const linked = wrapping('Storage', seams.get('Storage') ?? [], scoped, (dep) => scope.resolve(dep));
       // Storage is a way out like the client surface — see `StorageGuard`.
       const guarded = new StorageGuard(entity.entityClass.getFields(), entity.name).guard(linked);
@@ -194,7 +203,7 @@ export async function installFrond(frond: FrondDescriptor, assembly: Assembly):
       // existed to make `repo.storage` true in both, back when `.storage` was the way in.
       //
       // Not registered for an OWNED entity: an aggregate's members are reached through it
-      // and nowhere else, and the default would be a second door under a name a handler
+      // and nowhere else, and the default would be a second facade under a name a handler
       // can spell. Every member is skipped, not just the one the key is named after —
       // that asymmetry was the whole hole.
       const repoKey = repositoryKeyOf(entity.name);
@@ -223,7 +232,8 @@ export async function installFrond(frond: FrondDescriptor, assembly: Assembly):
   // so nothing is registered for a frame nobody wants.
   registerFrames(
     scope,
-    [...frond.handlers, ...frond.providers, ...frond.presenters, ...frond.collectors].flatMap((d) => d.deps),
+    [...frond.handlers, ...frond.providers, ...frond.presenters, ...frond.collectors]
+      .flatMap((d) => d.deps.map((key) => ({ key, filePath: d.filePath }))),
     frond.providers,
     {
       entityByName,
@@ -235,6 +245,7 @@ export async function installFrond(frond: FrondDescriptor, assembly: Assembly):
       transacted: options.transacted,
       log: frondLog,
     },
+    refused,
   );
 
   // Register presenters in scope — PascalCase type name (e.g. 'PostPresenter')
@@ -278,7 +289,7 @@ export async function installFrond(frond: FrondDescriptor, assembly: Assembly):
   const surfaceHandlers = frond.handlers.filter((h) => h.surface);
   const defaultHandlerMap = new Map(defaultHandlers.map((h) => [h.address, h]));
 
-  /** Build the door of a handler and register it under the audience it serves. */
+  /** Build the facade of a handler and register it under the audience it serves. */
   const buildFacade = (
     entity: EntityEntry | undefined,
     handler: HandlerEntry,
@@ -304,7 +315,7 @@ export async function installFrond(frond: FrondDescriptor, assembly: Assembly):
     });
     // Emissions use the same contracts and execution path as direct calls.
     emissions.note(facade.contracts, facadeKey);
-    // The terms alongside the door, under the same audience — a surface that serves
+    // The terms alongside the facade, under the same audience — a surface that serves
     // fewer ops describes fewer ops.
     container.registerValue(contractsKeyOf(handler.address, handler.surface), facade.contracts);
     effectiveByKey.set(facadeKey, facade.effectiveOperations);
@@ -381,7 +392,7 @@ export async function installFrond(frond: FrondDescriptor, assembly: Assembly):
   //
   // Pointing at nothing is legal HERE TOO. This loop used to `continue` when no entity
   // carried the handler's name, so `handlers/public/SearchHandler.ts` with no `Search`
-  // entity got no door at all and no line saying why — while the very same handler at
+  // entity got no facade at all and no line saying why — while the very same handler at
   // the default surface is built and logged. One rule, both surfaces.
   for (const handler of surfaceHandlers) {
     const entity = frond.entities.find((e) => e.name === handler.address);
@@ -390,14 +401,14 @@ export async function installFrond(frond: FrondDescriptor, assembly: Assembly):
     // Register scoped storage if output override differs from entity — under the REPOSITORY
     // key, which is what a Crud handler asks for, and under the port's own for a holder
     // that legitimately names it. Registering only the latter left a named surface with
-    // no door at all once the façade stopped spelling the storage.
+    // no facade at all once the façade stopped spelling the storage.
     if (entity && options.storageFactory) {
       const baseStorage = options.storageFactory(entity.entityClass, entity.name);
       const outputSchema = handler.outputOverride ?? (handler.ctor as any).__output;
       const scoped = outputSchema && outputSchema !== entity.entityClass
         ? baseStorage.output(outputSchema)
         : baseStorage;
-      // The view is handed over so a filter on a field this door hides is SAID. The
+      // The view is handed over so a filter on a field this facade hides is SAID. The
       // guard holds no logger — a warning is the boot's to voice, as a seed's report is.
       const guarded = new StorageGuard(entity.entityClass.getFields(), entity.name, {
         ...(outputSchema && outputSchema !== entity.entityClass

package/src/boot/ownership.ts

@@ -1,34 +1,44 @@
 import { lowerFirst } from '@fougere/schema';
-import { nameOf, type FrondDescriptor, type ProviderEntry } from '../descriptor/frond.js';
-import { inheritsCrud } from '../prefab/crud.js';
+import { nameOf, type FrondDescriptor } from '../descriptor/FrondDescriptor.js';
+import { type ProviderEntry } from '../descriptor/ProviderEntry.js';
+import { inheritsCrud } from '../prefab/CrudConstructor.js';
 import { targetOf } from '../prefab/prefab.js';
-import { ownedBy, repositoryKeyOf } from '../prefab/repository.js';
-import { entityOfStorageKey } from '../storage/port.js';
+import { ownedBy, repositoryKeyOf } from '../prefab/RepositoryConstructor.js';
+import { entityOfStorageKey } from '../storage/Storage.js';
+import type { Diagnostic } from '../diagnostic.js';
 
 /** One name, one file: two providers under one key and the second silently replaces the first. */
-export function refuseSharedName(frond: FrondDescriptor): void {
+export function sharedNames(frond: FrondDescriptor, refused: Diagnostic[]): void {
   const declared = new Map<string, string>();
 
   for (const provider of frond.providers) {
     const name = nameOf(provider);
     const first = declared.get(name);
     if (first !== undefined) {
-      throw new Error(
-        `[provider] two files declare ${name}:\n`
-        + `    ${first}\n`
-        + `    ${provider.filePath}\n`
-        + `  A frond registers both under one key, so the second replaces the first and whoever `
-        + `asks for ${name} is handed whichever was scanned last.\n`
-        + '  Rename one of the two.',
-      );
+      refused.push({
+        severity: 'blocking',
+        code: 'provider-name-taken',
+        filePath: provider.filePath,
+        frond: frond.name,
+        subject: name,
+        message: `${first} already declares ${name}. A frond registers both under one key, so the `
+          + `second replaces the first and whoever asks for ${name} is handed whichever was `
+          + 'scanned last. Rename one of the two.',
+      });
     }
     declared.set(name, provider.filePath);
   }
 }
 
 /** Who owns an entity's storage. */
-export function ownersOf(providers: readonly ProviderEntry[]): Map<string, string> {
+export function ownersOf(
+  providers: readonly ProviderEntry[],
+  frond: string,
+  refused: Diagnostic[],
+): Map<string, string> {
   const owners = new Map<string, string>();
+  /** Claimed twice, so it has no owner — and no owner is nobody to judge a reader against. */
+  const contested = new Set<string>();
   for (const provider of providers) {
     const owned = ownedBy(provider.ctor);
     if (owned.length < 2) continue;
@@ -39,14 +49,26 @@ export function ownersOf(providers: readonly ProviderEntry[]): Map<string, strin
         // Refused rather than settled, for the reason `ports:` refuses two implementations
         // and `remotes` two owners of an entity: whichever won would depend on scan order,
         // and one of the two aggregates would be silently unenforced.
-        throw new Error(
-          `[aggregate] ${first} and ${provider.ctor.name} both own ${name}. `
-          + 'An entity has one owner: merge the two, or take it out of one of them.',
-        );
+        refused.push({
+          severity: 'blocking',
+          code: 'entity-owned-twice',
+          filePath: provider.filePath,
+          frond,
+          subject: name,
+          message: `${first} and ${provider.ctor.name} both own ${name}. An entity has one owner: `
+            + 'merge the two, or take it out of one of them.',
+        });
+        contested.add(name);
+        continue;
       }
       owners.set(name, provider.ctor.name);
     }
   }
+  // The second claimant is BUILT ON what it claims, so `storageInUserCode` would read it as
+  // reaching around the first — two more refusals naming the same declaration, in the one
+  // case where the answer to "who owns this" is already the diagnostic above.
+  for (const name of contested) owners.delete(name);
+
   return owners;
 }
 
@@ -62,12 +84,13 @@ function builtOn(ctor: unknown): string[] {
 }
 
 /** `Storage<E>` is not a word of the user's vocabulary — `<E>Repository` is the one way in. */
-export function refuseStorageInUserCode(
+export function storageInUserCode(
   frond: FrondDescriptor,
   owners: Map<string, string>,
   known: (entity: string) => boolean,
+  refused: Diagnostic[],
 ): void {
-  const doors = [
+  const facades = [
     ...frond.handlers.map((h) => ({ ...h, kind: 'handler' })),
     ...frond.presenters.map((p) => ({ ...p, kind: 'presenter' })),
     ...frond.collectors.map((c) => ({ ...c, kind: 'collector' })),
@@ -81,15 +104,19 @@ export function refuseStorageInUserCode(
     const held = entityOfStorageKey(registered, known);
     if (!held) continue;
 
-    throw new Error(
-      `[storage] ${registered} is a provider, and it is the container key of ${held}'s `
-      + `own storage — the storage is registered second, so the provider is never resolved.\n`
-      + `  Name it for what it holds; \`<Entity>Storage\` belongs to the entity.\n`
-      + `  ${provider.filePath}`,
-    );
+    refused.push({
+      severity: 'blocking',
+      code: 'storage-key-is-provider',
+      filePath: provider.filePath,
+      frond: frond.name,
+      subject: registered,
+      message: `${registered} is a provider, and it is the container key of ${held}'s own storage `
+        + '— the storage is registered second, so the provider is never resolved. Name it for '
+        + 'what it holds; `<Entity>Storage` belongs to the entity.',
+    });
   }
 
-  for (const decl of [...doors, ...holders]) {
+  for (const decl of [...facades, ...holders]) {
     const allowed = decl.kind === 'provider' ? builtOn(decl.ctor) : [];
     for (const dep of decl.deps) {
       const entity = entityOfStorageKey(dep, known);
@@ -97,42 +124,55 @@ export function refuseStorageInUserCode(
 
       const owner = owners.get(entity);
       if (owner && owner !== decl.ctor.name) {
-        throw new Error(
-          `[aggregate] ${decl.ctor.name} asks for ${dep}, and ${owner} owns ${entity}.\n`
-          + `  Nothing else reaches an owned entity's storage — name the operation on `
-          + `${owner} and ask for it:\n`
-          + `    constructor(private ${entity}: ${owner}) {}\n`
-          + `  ${decl.filePath}`,
-        );
+        refused.push({
+          severity: 'blocking',
+          code: 'aggregate-storage-reached',
+          filePath: decl.filePath,
+          frond: frond.name,
+          subject: `${decl.ctor.name}(${dep})`,
+          message: `${decl.ctor.name} asks for ${dep}, and ${owner} owns ${entity}. Nothing else `
+            + `reaches an owned entity's storage — name the operation on ${owner} and ask for it: `
+            + `constructor(private ${entity}: ${owner}) {}`,
+        });
+        continue;
       }
       if (allowed.includes(entity)) continue;
 
-      throw new Error(
-        `${decl.ctor.name} asks for ${dep}. Storage is reached through a repository, `
-        + `never through the port:\n`
-        + `    constructor(private ${entity}: ${repositoryKeyOf(entity)}) {}\n`
-        + `  It answers every gesture ${dep} does, whether or not anyone wrote the file — `
-        + `and the day ${entity} belongs to an aggregate, this line does not move.\n`
-        + `  ${decl.filePath}`,
-      );
+      refused.push({
+        severity: 'blocking',
+        code: 'storage-outside-repository',
+        filePath: decl.filePath,
+        frond: frond.name,
+        subject: `${decl.ctor.name}(${dep})`,
+        message: `${decl.ctor.name} asks for ${dep}. Storage is reached through a repository, never `
+          + `through the port: constructor(private ${entity}: ${repositoryKeyOf(entity)}) {}. It `
+          + `answers every gesture ${dep} does, whether or not anyone wrote the file — and the day `
+          + `${entity} belongs to an aggregate, this line does not move.`,
+      });
     }
   }
 }
 
 /** An owned entity has no automatic CRUD — said at boot, not at the first request. */
-export function refuseCrudOnOwned(frond: FrondDescriptor, owners: Map<string, string>): void {
+export function crudOnOwned(
+  frond: FrondDescriptor,
+  owners: Map<string, string>,
+  refused: Diagnostic[],
+): void {
   for (const handler of frond.handlers) {
     const owner = owners.get(handler.address);
     if (!owner || handler.deps.length > 0 || !inheritsCrud(handler.ctor)) continue;
 
-    throw new Error(
-      `[aggregate] ${handler.ctor.name} takes the five gestures on ${handler.address}, `
-      + `which ${owner} owns.\n`
-      + `  An owned entity has no automatic CRUD: nothing writes it but its owner, so there `
-      + `is no storage to hand this handler.\n`
-      + `  Name the operations on ${owner} and call them:\n`
-      + `    constructor(private ${handler.address}: ${owner}) {}\n`
-      + `  ${handler.filePath}`,
-    );
+    refused.push({
+      severity: 'blocking',
+      code: 'crud-on-owned-entity',
+      filePath: handler.filePath,
+      frond: frond.name,
+      subject: handler.ctor.name,
+      message: `${handler.ctor.name} takes the five gestures on ${handler.address}, which ${owner} `
+        + 'owns. An owned entity has no automatic CRUD: nothing writes it but its owner, so there '
+        + `is no storage to hand this handler. Name the operations on ${owner} and call them: `
+        + `constructor(private ${handler.address}: ${owner}) {}`,
+    });
   }
 }

package/src/boot/ports.ts

@@ -1,4 +1,7 @@
-import { nameOf, type ProviderEntry } from '../descriptor/frond.js';
+import { nameOf } from '../descriptor/FrondDescriptor.js';
+import { type ProviderEntry } from '../descriptor/ProviderEntry.js';
+import { basesOf } from '../descriptor/bases.js';
+import type { Diagnostic } from '../diagnostic.js';
 
 /**
  * The framework's own ports — a class core exports that a user class may stand in front of.
@@ -24,23 +27,29 @@ export const SEAMS = new Set(['Storage']);
 export function seamChains(
   providers: ProviderEntry[],
   chosen: Record<string, string | readonly string[]> | undefined,
+  refused: Diagnostic[],
 ): Map<string, ProviderEntry[]> {
   const wrappers = new Map<string, ProviderEntry[]>();
   for (const provider of providers) {
     const seam = (Object.getPrototypeOf(provider.ctor) as { name?: string } | null)?.name;
     if (!seam || !SEAMS.has(seam)) continue;
     if (!provider.deps.includes(seam)) {
-      throw new Error(
-        `[ports] ${nameOf(provider)} extends ${seam}, and a seam's realization is handed in `
-        + `rather than declared — so a class extending one can only stand IN FRONT of it, `
-        + `which it says by asking for it: constructor(private inner: ${seam}).`,
-      );
+      refused.push({
+        severity: 'blocking',
+        code: 'seam-not-wrapped',
+        filePath: provider.filePath,
+        subject: nameOf(provider),
+        message: `${nameOf(provider)} extends ${seam}, and a seam's realization is handed in rather `
+          + 'than declared — so a class extending one can only stand IN FRONT of it, which it says '
+          + `by asking for it: constructor(private inner: ${seam}).`,
+      });
+      continue;
     }
     wrappers.set(seam, [...(wrappers.get(seam) ?? []), provider]);
   }
 
   const bound = new Map<string, ProviderEntry[]>();
-  for (const [seam, all] of wrappers) bound.set(seam, chain(seam, [], all, chosen?.[seam]));
+  for (const [seam, all] of wrappers) bound.set(seam, chain(seam, [], all, chosen?.[seam], refused));
 
   return bound;
 }
@@ -77,22 +86,9 @@ export function portBindings(
   providers: ProviderEntry[],
   answers: (name: string) => boolean,
   chosen: Record<string, string | readonly string[]> | undefined,
+  refused: Diagnostic[],
 ): Map<string, ProviderEntry[]> {
-  // port class name → the classes that extend it, in scan order.
-  const candidates = new Map<string, ProviderEntry[]>();
-  for (const provider of providers) {
-    const base = Object.getPrototypeOf(provider.ctor) as { name?: string } | null;
-    const port = base?.name;
-    // ONE condition: something already answers under that name. Providers are
-    // registered into this scope just above, and the builtins sit in its parent, so
-    // this covers a neighbour service and `Logger` alike — a framework class is a
-    // port like any other, which is what makes a default overridable.
-    //
-    // It is also what excludes a prefab: a repository extends the class
-    // `Repository(Post)` returned (`RepositoryBase`), and no key is ever that name.
-    if (!port || !answers(port)) continue;
-    candidates.set(port, [...(candidates.get(port) ?? []), provider]);
-  }
+  const candidates = basesOf(providers, answers);
 
   const bound = new Map<string, ProviderEntry[]>();
   for (const [port, all] of candidates) {
@@ -102,7 +98,7 @@ export function portBindings(
     const impls = all.filter((one) => !wraps(one));
     const stated = chosen?.[port];
 
-    bound.set(port, chain(port, impls, wrappers, stated));
+    bound.set(port, chain(port, impls, wrappers, stated, refused));
   }
 
   return bound;
@@ -113,6 +109,7 @@ function chain(
   impls: ProviderEntry[],
   wrappers: ProviderEntry[],
   stated: string | readonly string[] | undefined,
+  refused: Diagnostic[],
 ): ProviderEntry[] {
   // The whole chain, outside in — a string is a chain of one, and the last name is what
   // actually answers. What a deployment wraps its realization with is the same kind of
@@ -121,16 +118,21 @@ function chain(
     const order = typeof stated === 'string' ? [stated] : stated;
     const all = [...wrappers, ...impls];
 
-    return order.map((name) => {
+    return order.flatMap((name) => {
       const pick = all.find((one) => nameOf(one) === name);
       if (!pick) {
-        throw new Error(
-          `[ports] ${port}: '${name}' does not extend it. `
-          + `What does: ${all.map(nameOf).join(', ')}.`,
-        );
+        refused.push({
+          severity: 'blocking',
+          code: 'port-not-extended',
+          filePath: all[0]?.filePath ?? 'fougere.config.ts',
+          subject: `ports: { ${port}: '${name}' }`,
+          message: `${port}: '${name}' does not extend it. What does: ${all.map(nameOf).join(', ')}.`,
+        });
+
+        return [];
       }
 
-      return pick;
+      return [pick];
     });
   }
 
@@ -138,22 +140,31 @@ function chain(
     // Refusing rather than keeping one, for the reason `remotes` refuses two owners
     // of an entity: whichever won would depend on scan order, and the handler would
     // charge the wrong provider without a word.
-    throw new Error(
-      `[ports] ${impls.map(nameOf).join(' and ')} both extend ${port}, `
-      + 'and nothing says which one answers it. Which realization a deployment uses is '
-      + `not a fact about the code — state it: ports: { ${port}: '${nameOf(impls[0]!)}' } `
-      + 'in fougere.config.ts.',
-    );
+    refused.push({
+      severity: 'blocking',
+      code: 'port-implemented-twice',
+      filePath: impls[0]!.filePath,
+      subject: port,
+      message: `${impls.map(nameOf).join(' and ')} both extend ${port}, and nothing says which one `
+        + 'answers it. Which realization a deployment uses is not a fact about the code — state it: '
+        + `ports: { ${port}: '${nameOf(impls[0]!)}' } in fougere.config.ts.`,
+    });
+
+    return [...wrappers, ...impls];
   }
 
   if (wrappers.length > 1) {
     // Same refusal one layer out: two wrappers are an ORDER, and scan order is not one.
-    throw new Error(
-      `[ports] ${wrappers.map(nameOf).join(' and ')} both wrap ${port}, `
-      + 'and nothing says which stands in front. State the chain, outside in: '
-      + `ports: { ${port}: [${[...wrappers, ...impls].map((one) => `'${nameOf(one)}'`).join(', ')}] } `
-      + 'in fougere.config.ts.',
-    );
+    refused.push({
+      severity: 'blocking',
+      code: 'port-wrapped-twice',
+      filePath: wrappers[0]!.filePath,
+      subject: port,
+      message: `${wrappers.map(nameOf).join(' and ')} both wrap ${port}, and nothing says which `
+        + 'stands in front. State the chain, outside in: '
+        + `ports: { ${port}: [${[...wrappers, ...impls].map((one) => `'${nameOf(one)}'`).join(', ')}] } `
+        + 'in fougere.config.ts.',
+    });
   }
 
   return [...wrappers, ...impls];