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

package/src/boot/bootstrap.ts

@@ -1,56 +1,55 @@
 import type { Container } from '@fougere/container';
-import { lowerFirst, type Fields, type SchemaView } from '@fougere/schema';
-import { nameOf } from '../descriptor/frond.js';
-import type { EntityEntry, HandlerEntry, PresenterEntry } from '../descriptor/frond.js';
+import { lowerFirst, type SchemaView } from '@fougere/schema';
+
+import type { HandlerEntry } from '../descriptor/HandlerEntry.js';
+import type { PresenterEntry } from '../descriptor/PresenterEntry.js';
 import { hostedBy } from './hosted.js';
 import { installFrond, type Assembly } from './install.js';
-import type { AuthRuntime } from './auth.js';
-import type { CreateAppOptions, App } from './types.js';
-import type { AppMiddleware } from '../wire/middleware.js';
-import { Carry, Logger } from '../builtin/logger.js';
-import type { LogRecord } from '../builtin/logger.js';
+import { refusalOf, type Diagnostic } from '../diagnostic.js';
+import type { AuthRuntime } from './AuthRuntime.js';
+import type { App } from './App.js';
+import type { CreateAppOptions } from './CreateAppOptions.js';
+import type { AppMiddleware } from '../wire/AppMiddleware.js';
+import { Carry } from '../builtin/Carry.js';
+import { Logger } from '../builtin/Logger.js';
+import type { LogRecord } from '../builtin/LogRecord.js';
 import LogLine, { CARRIES_LINE } from '../builtin/LogLine.js';
-import { emitKeyOf, type Emit } from '../wire/emit.js';
+import { emitKeyOf, type Emit } from '../wire/Emit.js';
 
 /** The fact the boot announces, spelled once. */
 const LOG_LINE = lowerFirst(LogLine.name);
 import { Config } from '../builtin/config.js';
 import { createRemoteRouter, createRemoteFacade } from './remote.js';
-import { registerFrames } from './together.js';
+
 import { Emissions } from './Emissions.js';
-import { HandlerFacade } from '../dispatch/HandlerFacade.js';
-import { targetOf } from '../prefab/prefab.js';
-import { ownersOf, refuseStorageInUserCode, refuseCrudOnOwned } from './ownership.js';
-import type { OperationContract, OperationsMap } from '../wire/operation.js';
-import {
-  resolveEffectiveOperations,
-  type EffectiveOperationsMap,
-} from '../effective-operation.js';
-import { StorageGuard } from '../dispatch/StorageGuard.js';
-import { portBindings } from './ports.js';
+
+import type { OperationContract } from '../wire/OperationContract.js';
+import type { OperationsMap } from '../wire/OperationsMap.js';
+import { resolveEffectiveOperations } from '../EffectiveOperationModel.js';
+import { type EffectiveOperationsMap } from '../EffectiveOperationsMap.js';
+
 import { InFlight } from '../dispatch/InFlight.js';
 // The keys, each read from where its concept is declared — never respelled here.
-import { facadeKeyOf, contractsKeyOf, type RpcAnswer } from '../wire/call.js';
+import { type RpcAnswer } from '../wire/RpcAnswer.js';
+import { facadeKeyOf } from '../wire/Facade.js';
 import { identityCardOf } from './card.js';
 import { AppLifecycle, migrating } from './AppLifecycle.js';
 import { seeding } from './seed.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 { storageKeyOf } from '../storage/Storage.js';
+
 import { presenterKeyOf } from '../prefab/presenter.js';
-import { collectorKeyOf } from '../prefab/collector.js';
+
 import { RouteAddress } from '../wire/RouteAddress.js';
 import { DispatchLifecycle } from '../dispatch/DispatchLifecycle.js';
 import { Dispatcher } from '../dispatch/Dispatcher.js';
 import { LocalRoutePolicy } from '../dispatch/LocalRoutePolicy.js';
-import { servedSurfaces } from '../descriptor/surface.js';
+
 import { OperationRoute } from '../dispatch/OperationRoute.js';
 import { remoteRoutes } from '../dispatch/remoteRoutes.js';
 import { RouteRegistry } from '../dispatch/RouteRegistry.js';
 import { facadeOperations } from '../entry/facade.js';
 
-
 /** The one wording for "nobody hosts this here", with both ways out. */
 const notLoaded = (entity: string) =>
   `Frond for '${entity}' is not loaded.\n` +
@@ -58,29 +57,39 @@ const notLoaded = (entity: string) =>
   `  - Or declare a remote: remotes: { ${entity}: 'http://...' }`;
 
 /** Two fronds cannot claim one name — said at boot, because nothing else says it. */
-function assertOneOwnerPerKey(
+function keyClaims(
   fronds: { name: string; handlers: HandlerEntry[]; presenters: PresenterEntry[] }[],
   remotes: Record<string, string> | undefined,
+  refused: Diagnostic[],
 ): void {
   const owner = new Map<string, string>();
+  const fileOf = new Map<string, string>();
 
-  const claim = (key: string, frond: string, what: string) => {
+  const claim = (key: string, frond: string, what: string, filePath: string) => {
     const first = owner.get(key);
     if (first !== undefined && first !== frond) {
-      throw new Error(
-        `Two fronds claim the key '${key}': '${first}' and '${frond}'.\n`
-        + `  A ${what} is registered under a key that names no frond, so one would silently replace the other.\n`
-        + `  - Rename one of the two classes, or\n`
-        + `  - keep one of the two fronds out of this process (--fronds), or declare it in remotes:`,
-      );
+      refused.push({
+        severity: 'blocking',
+        code: 'frond-key-taken',
+        filePath,
+        frond,
+        subject: key,
+        message: `'${first}' and '${frond}' both claim the key '${key}'. A ${what} is registered `
+          + 'under a key that names no frond, so one would silently replace the other. Rename one '
+          + 'of the two classes, or keep one frond out of this process (--fronds). '
+          + `'${first}' declares it in ${fileOf.get(key)}.`,
+      });
+
+      return;
     }
     owner.set(key, frond);
+    fileOf.set(key, filePath);
   };
 
   for (const frond of fronds) {
     if (remotes && frond.name in remotes) continue;
-    for (const handler of frond.handlers) claim(facadeKeyOf(handler.address, handler.surface), frond.name, 'door');
-    for (const presenter of frond.presenters) claim(presenterKeyOf(presenter.entityName), frond.name, 'presenter');
+    for (const handler of frond.handlers) claim(facadeKeyOf(handler.address, handler.surface), frond.name, 'facade', handler.filePath);
+    for (const presenter of frond.presenters) claim(presenterKeyOf(presenter.entityName), frond.name, 'presenter', presenter.filePath);
   }
 }
 
@@ -171,7 +180,9 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
     if (!options.fronds && !options.scan && !options.auth && brought.length === 0) {
       throw new Error(
         'createApp needs `fronds:` (what this app states) or `scan:` (what a scanner found). '
-        + 'Neither was given, and nothing else declares entities of its own.',
+        + 'Neither was given, and nothing else declares entities of its own.\n'
+        + '    createApp({ fronds: [blog] })\n'
+        + '    createApp({ scan: await scanProject(root) })',
       );
     }
     const operationModel = resolveEffectiveOperations(fronds, {
@@ -189,17 +200,8 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
     for (const d of diagnostics) if (d.severity === 'warning') log.warn(`[${d.code}] ${d.message}`);
 
     /** An ambiguous convention is not a partial scan. */
-    const invalidOperations = operationModel.resolutionDiagnostics
-      .filter((diagnostic) => diagnostic.severity === 'blocking');
-    if (invalidOperations.length > 0) {
-      const details = invalidOperations.map((d) =>
-        `  [${d.code}]${d.subject ? ` ${d.subject}` : ''}\n    ${d.message}\n    ${d.filePath}`,
-      );
-      throw new Error(
-        `Fougere boot refused: ${invalidOperations.length} unresolved operation contract(s):\n`
-        + details.join('\n'),
-      );
-    }
+    const unresolved = refusalOf(operationModel.resolutionDiagnostics, 'unresolved operation contract(s)');
+    if (unresolved) throw unresolved;
 
     // Auth runtime — built once from the lazy AuthConfig produced by a provider factory
     // (e.g. betterAuth({...})) in fougere.config.ts. The provider receives our db +
@@ -207,7 +209,7 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
     let authRuntime: AuthRuntime | undefined;
     if (options.auth) {
       if (!options.storageFactory) {
-        throw new Error('createApp: `auth` is set but `storageFactory` is missing — auth providers need it to back their adapter.');
+        throw new Error('createApp: `auth` is set but `storageFactory` is missing — auth providers need it to back their adapter. Pass one through CreateAppOptions.storageFactory.');
       }
       if (options.db === undefined) {
         throw new Error('createApp: `auth` is set but `db` is missing — pass the storage handle through CreateAppOptions.db.');
@@ -233,7 +235,7 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
       ? createRemoteRouter(Object.fromEntries(declaredRemotes), options.remoteTransport)
       : undefined;
 
-    // What is running on this app — counted at the one door every caller goes through,
+    // What is running on this app — counted at the one facade every caller goes through,
     // so releasing it can wait for the work instead of pulling the floor out.
     const inflight = new InFlight();
 
@@ -276,7 +278,13 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
       scopedMiddlewares.set(entity, scoped);
     }
 
-    assertOneOwnerPerKey(fronds, options.remotes);
+    /** What every check of this boot writes into — refused together, once they have all run. */
+    const refused: Diagnostic[] = [];
+    keyClaims(fronds, options.remotes, refused);
+    // Said before anything is installed: a key claimed twice makes every later error worse —
+    // the route registry collides first, and names a route instead of the two fronds.
+    const claimed = refusalOf(refused, 'declaration(s) that do not hold');
+    if (claimed) throw claimed;
 
     // Every entity of every frond, by name — so a fact can be validated where it LANDS, and
     // so a `reads:` clause can name a neighbour's.
@@ -295,6 +303,7 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
       fronds, entityByName, container,
       // No carry: this is what CARRIES a fact, and a line about carrying one comes back.
       new Logger('boot:app'),
+      refused,
       options.onEmit,
     );
     /** Canonical operation tables, indexed by the same audience key as their facades. */
@@ -313,11 +322,16 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
     // table, one emission list — so what a frond serves is there for the next one to find.
     const assembly: Assembly = {
       container, routeRegistry, emissions, dispatcher, localDispatcher, effectiveByKey,
-      boundPorts, operationModel, entityByName, frondOf, contractsOf, getMiddlewares, use,
+      boundPorts, refused, operationModel, entityByName, frondOf, contractsOf, getMiddlewares, use,
       log, options,
     };
     for (const frond of fronds) await installFrond(frond, assembly);
 
+    // Every check of the install, said at once — a boot that stops at the first makes the
+    // next one visible only after a fix and a restart.
+    const bootRefusal = refusalOf(refused, 'declaration(s) that do not hold');
+    if (bootRefusal) throw bootRefusal;
+
     // A `ports:` key that matched no port anywhere reads as a choice that was made, and
     // was not. Said once, at the end, because the entry is app-wide while a port is a
     // frond's — no single frond can tell whether a key is a typo or a neighbour's.
@@ -329,14 +343,19 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
       );
     }
 
-    // Once every door exists: what is announced here and what is listened to are both known.
+    // Once every facade exists: what is announced here and what is listened to are both known.
     emissions.register();
 
-    // Which doors carry a line, read from who SUBSCRIBED — so a third party's destination
+    // The third phase: what a fact's links and its answer type state. Said after `register`,
+    // which is where a pipe order and an `Emit<T, A>` are read.
+    const announced = refusalOf(refused, 'declaration(s) that do not hold');
+    if (announced) throw announced;
+
+    // Which facades carry a line, read from who SUBSCRIBED — so a third party's destination
     // is left alone by the two middlewares that observe every operation.
-    for (const door of emissions.doorsFor(LOG_LINE)) {
-      CARRIES_LINE.add(door.replace(/Handler$/, '').replace(/^./, (c) => c.toLowerCase()));
-      CARRIES_LINE.add(door);
+    for (const facade of emissions.facadesFor(LOG_LINE)) {
+      CARRIES_LINE.add(facade.replace(/Handler$/, '').replace(/^./, (c) => c.toLowerCase()));
+      CARRIES_LINE.add(facade);
     }
 
     /** The last resort, held by the container so every resolution path shares it. */
@@ -353,7 +372,6 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
       );
     });
 
-
     /** Stop taking calls, and resolve once the ones already running are done. */
     const drain = async (timeoutMs?: number): Promise<void> => {
       inflight.close();
@@ -386,7 +404,7 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
       if (found) return found.entityClass;
       if (remoteRouter) {
         const route = await remoteRouter.route(entity);
-        // A remote door that stores nothing publishes ops and no shape. Saying so beats
+        // A remote facade that stores nothing publishes ops and no shape. Saying so beats
         // handing back an empty schema, which would validate every input it was given.
         if (!route.schema) {
           throw new Error(
@@ -409,12 +427,12 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
       }
     };
 
-    /** Said once per pair, so a door that registers in a loop says it once. */
+    /** Said once per pair, so a facade that registers in a loop says it once. */
     const saidAbsent = new Set<string>();
 
     /**
      * A surface is declared in the frond that serves it. When that frond runs in another
-     * process, this one never asked for its doors, and answering 'no' is the only thing a
+     * process, this one never asked for its facades, and answering 'no' is the only thing a
      * synchronous rule can do — so it says so rather than registering nothing in silence.
      */
     const sayNoSurfaceAcross = (entity: string, surface: string): void => {
@@ -422,8 +440,8 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
       saidAbsent.add(`${surface}:${entity}`);
       log.warn(
         `surface '${surface}' serves nothing for '${entity}' — the frond that declares it runs `
-        + 'elsewhere, and a remote is asked for its doors at the first call, not at boot. '
-        + 'The default door answers.',
+        + 'elsewhere, and a remote is asked for its facades at the first call, not at boot. '
+        + 'The default facade answers.',
       );
     };
 
@@ -465,7 +483,7 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
       }));
     }
 
-    /** The terms beside a door, with the exact same named-surface fallback rule. */
+    /** The terms beside a facade, with the exact same named-surface fallback rule. */
     const operationsFor = (entity: string, surface?: string): EffectiveOperationsMap | undefined => {
       if (!surface) return effectiveByKey.get(facadeKeyOf(entity));
 
@@ -479,7 +497,7 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
 
     /**
      * The storage an entity is backed by — the dual of `facadeFor`, which serves its client-facing
-     * door.
+     * facade.
      */
     const storageFor = (entity: string): unknown | undefined => {
       const owner = fronds.owner(entity);
@@ -508,7 +526,7 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
     const app: App = {
       container,
       fronds,
-      // What this app publishes, straight from fougere.config.ts — the doors read it,
+      // What this app publishes, straight from fougere.config.ts — the facades read it,
       // so an undeclared adapter serves nothing whatever a host mounted.
       adapters: options.adapters ?? {},
       // Where a call goes, as DECLARED. Kept because a reader needs it beside what the
@@ -534,7 +552,10 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
         // depend on wiring order, and `discover` is in here precisely so it cannot be taken.
         const address = new RouteAddress({ entity: 'rpc', operation: op });
         if (routeRegistry.find(address)) {
-          throw new Error(`rpc operation '${op}' is already served; a second declaration would depend on wiring order`);
+          throw new Error(
+            `[claim] rpc operation '${op}' is already served; a second declaration would depend on wiring order.\n`
+            + '  Two extensions declare it — keep one out of `extensions:`.',
+          );
         }
         routeRegistry.register(new OperationRoute(
           'system',
@@ -561,10 +582,20 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
     // The last thing the boot does, and the first thing a release undoes. An extension may
     // await here — which is what a provider needing to OPEN something could never do.
     built = app;
+
+    // What the FRONDS declared, folded in after what the host handed over — a frond's
+    // extension is written beside the code it instruments and travels with it, so it mounts
+    // on whichever process ends up serving that frond. Added here rather than at the top
+    // because the fronds are read below that line, and `up` has not run yet.
+    appLifecycle.add(...fronds.flatMap((frond) => (frond.extensions ?? []).map((one) => ({
+      name: one.name,
+      ...one.extension,
+    }))));
+
     await appLifecycle.up(app);
 
     // The boot's own lines, and every line after them. Held until here because a boot
-    // writes most of what a process logs and writes it before any door exists — so the
+    // writes most of what a process logs and writes it before any facade exists — so the
     // lines that say what this app is made of are the ones a destination would miss.
     // `LogLine` is core's for this reason: naming it costs no optional package.
     //

package/src/boot/card.ts

@@ -1,10 +1,11 @@
 /** What an app says about ITSELF — the `rpc.discover` answer, built from the app. */
 import { Card } from '@fougere/schema';
-import type { App } from './types.js';
-import { factsAnnouncedBy } from '../wire/emit.js';
-import type { InvocationContext } from '../wire/Invocation.js';
-import { facadeKeyOf, contractsKeyOf, type CardOp, type IdentityCard } from '../wire/call.js';
-import type { OperationContract } from '../wire/operation.js';
+import type { App } from './App.js';
+import { factsAnnouncedBy } from '../wire/Emit.js';
+import type { InvocationContext } from '../wire/InvocationContext.js';
+import { type CardOp } from '../wire/card/CardOp.js';
+import { type IdentityCard } from '../wire/card/IdentityCard.js';
+import { facadeKeyOf } from '../wire/Facade.js';
 
 type AnyFacade = Record<string, (invocation?: InvocationContext) => Promise<unknown>>;
 
@@ -16,12 +17,12 @@ export function identityCardOf(app: App, surface?: string): IdentityCard {
     // What this app SERVES, never what instruments it. A frond an extension BROUGHT is a
     // subscriber — `@fougere/calls` and `@fougere/observability` each bring one — and it is
     // in every process that installed the extension, so two remotes then claimed the same
-    // door and routing refused: `Two remotes serve 'export'`. `FrondDescriptor.brought` is
+    // facade and routing refused: `Two remotes serve 'export'`. `FrondDescriptor.brought` is
     // the mark `calls`' panel and `rpc.topology` already read.
     fronds: app.fronds.filter((frond) => !frond.brought).map((frond) => {
       // What the frond answers to, not what it stores. This walked `frond.entities`, so a
       // handler carrying no entity — a health check, a search across shapes — was built,
-      // served, and absent from the card: `sync` could not generate its door and a remote
+      // served, and absent from the card: `sync` could not generate its facade and a remote
       // consumer had no way to know it existed. The boot has said "pointing at nothing is
       // legal" since handlers became the subject; the card had not caught up.
       const byEntity = new Map(frond.entities.map((entity) => [entity.name, entity]));
@@ -32,14 +33,14 @@ export function identityCardOf(app: App, surface?: string): IdentityCard {
 
       return {
         name: frond.name,
-        doors: addresses.flatMap((address) => {
+        facades: addresses.flatMap((address) => {
           const ops = facadeOps(app, address, surface);
           if (ops.length === 0) return [];
           const entity = byEntity.get(address);
           return [{
             name: address,
             ops,
-            // Absent when nothing of that name is stored. A door is still a door.
+            // Absent when nothing of that name is stored. A facade is still a facade.
             ...(entity ? { schema: Card.fromSchema(entity.entityClass, address).descriptor } : {}),
           }];
         }),
@@ -65,7 +66,8 @@ function facadeOps(app: App, entityName: string, surface?: string): CardOp[] {
   const effective = app.operationsFor(entityName, surface);
   if (!effective) {
     throw new Error(
-      `Facade '${facadeKeyOf(entityName, surface)}' exists without an effective operation table.`,
+      `Facade '${facadeKeyOf(entityName, surface)}' exists without an effective operation table. `
+      + 'A facade and its table are built together, so no declaration can produce this.',
     );
   }
 
@@ -73,7 +75,8 @@ function facadeOps(app: App, entityName: string, surface?: string): CardOp[] {
     const contract = effective.get(name);
     if (!contract) {
       throw new Error(
-        `Facade '${facadeKeyOf(entityName, surface)}' serves '${name}' without an effective contract.`,
+        `Facade '${facadeKeyOf(entityName, surface)}' serves '${name}' without an effective contract. `
+        + 'A facade and its table are built together, so no declaration can produce this.',
       );
     }
 
@@ -83,6 +86,7 @@ function facadeOps(app: App, entityName: string, surface?: string): CardOp[] {
       ...(contract?.input && { input: Card.fromSchema(contract.input, name).descriptor }),
       ...(contract?.output && { output: Card.fromSchema(contract.output, name).descriptor }),
       ...(contract?.cardinality && { cardinality: contract.cardinality }),
+      ...(contract.errors?.length ? { errors: contract.errors } : {}),
       kind: contract.kind,
     };
   });

package/src/boot/declared.ts

@@ -0,0 +1,91 @@
+/**
+ * What an app says about its NEIGHBOURS — the dual of the identity card, which says what it IS.
+ *
+ * Documented: [observability](https://fougere.dev/docs/infra/observability).
+ */
+import type { FrondDescriptor } from '../descriptor/FrondDescriptor.js';
+import { facadeKeyOf } from '../wire/Facade.js';
+import { type DeclaredEdge } from '../wire/topology/DeclaredEdge.js';
+import { type DeclaredFrond } from '../wire/topology/DeclaredFrond.js';
+import { type DeclaredTopology } from '../wire/topology/DeclaredTopology.js';
+
+interface Declaring {
+  fronds: readonly FrondDescriptor[];
+  remotes: Readonly<Record<string, string>>;
+}
+
+/** Read from the config and the scan, never from a call, so nothing has to answer for it. */
+export function declaredTopologyOf({ fronds, remotes }: Declaring): DeclaredTopology {
+  const hosted = fronds.filter((frond) => !frond.brought);
+
+  return { fronds: placements(hosted, remotes), edges: crossings(hosted) };
+}
+
+function placements(hosted: readonly FrondDescriptor[], remotes: Readonly<Record<string, string>>): DeclaredFrond[] {
+  const here = hosted
+    .filter((frond) => !remotes[frond.name])
+    .map((frond) => ({ frond: frond.name, placement: 'local' as const }));
+
+  const elsewhere = Object.entries(remotes)
+    .map(([frond, address]) => ({ frond, placement: 'remote' as const, at: hostOf(address) }));
+
+  return [...here, ...elsewhere];
+}
+
+/**
+ * Which frond serves each address — indexed FORWARD, so a dependency is recognized by what
+ * answers it and never by its spelling. A surface is left out: its key carries a `:`, and no
+ * dependency can name one.
+ */
+export function servedBy(fronds: readonly FrondDescriptor[]): Map<string, string> {
+  const index = new Map<string, string>();
+  for (const frond of fronds) {
+    if (frond.brought) continue;
+    for (const handler of frond.handlers) {
+      if (handler.surface) continue;
+      index.set(facadeKeyOf(handler.address), frond.name);
+    }
+  }
+
+  return index;
+}
+
+/**
+ * The fronds one class reaches through a façade — the only sanctioned crossing.
+ *
+ * An address no scanned frond serves is left out rather than guessed: naming the frond behind it
+ * means reading its card, and a card is a DISCOVERY, which belongs to the other half of the
+ * report. This answers what the CODE declares, and never more.
+ */
+export function reachedBy(deps: readonly string[], from: string, index: Map<string, string>): string[] {
+  const reached = deps
+    .map((dependency) => index.get(dependency))
+    .filter((frond): frond is string => frond !== undefined && frond !== from);
+
+  return [...new Set(reached)];
+}
+
+function crossings(hosted: readonly FrondDescriptor[]): DeclaredEdge[] {
+  const index = servedBy(hosted);
+  const found = new Map<string, DeclaredEdge>();
+
+  for (const frond of hosted) {
+    for (const handler of frond.handlers) {
+      for (const to of reachedBy(handler.deps, frond.name, index)) {
+        found.set(`${frond.name} ${to}`, { from: frond.name, to });
+      }
+    }
+  }
+
+  return [...found.values()];
+}
+
+function hostOf(address: string): string {
+  try {
+    const url = new URL(address);
+
+    return `${url.protocol}//${url.host}`;
+  } catch {
+    return address;
+  }
+}

package/src/boot/frame.ts

@@ -4,8 +4,8 @@
  */
 import { FieldSet, type SchemaView } from '@fougere/schema';
 import { dequal } from 'dequal';
-import { declares } from '../source.js';
-import type { Logger } from '../builtin/logger.js';
+import { declares } from '../Source.js';
+import type { Logger } from '../builtin/Logger.js';
 
 /** One write that landed, and how to take it back. */
 export interface Undo {

package/src/boot/hosted.ts

@@ -1,5 +1,5 @@
 /** What this app hosts — what it STATED, or what a scan FOUND. */
-import type { FrondDescriptor } from '../descriptor/frond.js';
+import type { FrondDescriptor } from '../descriptor/FrondDescriptor.js';
 import type { ScanResult } from '../scan.js';
 import { Fronds } from '../descriptor/Fronds.js';