@fougere/core 0.12.1-alpha.0 → 0.12.4-alpha.0

package/src/boot/card.ts

@@ -37,6 +37,7 @@ export function identityCardOf(app: App, surface?: string): IdentityCard {
           const ops = facadeOps(app, address, surface);
           if (ops.length === 0) return [];
           const entity = byEntity.get(address);
+
           return [{
             name: address,
             ops,
@@ -47,6 +48,7 @@ export function identityCardOf(app: App, surface?: string): IdentityCard {
         /** What leaves on its own — the same list on every surface, deliberately. */
         facts: factsAnnouncedBy(frond.handlers).map((name) => {
           const entityClass = declared.get(name);
+
           return { name, ...(entityClass ? { schema: Card.fromSchema(entityClass, name).descriptor } : {}) };
         }),
       };

package/src/boot/frame.ts

@@ -83,6 +83,7 @@ function recordCreate({ base, recorded, entity, key, journal }: Recording): void
     const row = await base.create.apply(this, args);
     const id = String(row[key]);
     journal.push({ what: `create ${entity}#${id}`, run: () => base.delete.call(this, id).then(() => undefined) });
+
     return row;
   };
 }
@@ -119,6 +120,7 @@ function recordUpdate({ base, recorded, entity, journal }: Recording): void {
         await base.update.call(this, id, pick(before, touched));
       },
     });
+
     return row;
   };
 }
@@ -131,6 +133,7 @@ function recordDelete({ base, recorded, entity, journal }: Recording): void {
     if (removed && before) {
       journal.push({ what: `delete ${entity}#${id}`, run: () => base.create.call(this, before).then(() => undefined) });
     }
+
     return removed;
   };
 }
@@ -144,6 +147,7 @@ function recordUpserts({ base, recorded, entity, key, journal }: Recording, sche
   const undoUpsert = async function (this: unknown, rows: readonly Record<string, unknown>[]): Promise<Undo> {
     const ids = rows.map((row) => String(row[key]));
     const before = await base.findByKeys.call(this, ids);
+
     return {
       what: `upsert ${entity} (${ids.length} row(s))`,
       run: async () => {
@@ -163,6 +167,7 @@ function recordUpserts({ base, recorded, entity, key, journal }: Recording, sche
       const undo = await undoUpsert.call(this, [input]);
       const row = await upsert.call(this, input, ...rest);
       journal.push(undo);
+
       return row;
     };
   }
@@ -174,6 +179,7 @@ function recordUpserts({ base, recorded, entity, key, journal }: Recording, sche
       const undo = await undoUpsert.call(this, inputs);
       const written = await upsertAll.call(this, inputs, ...rest);
       journal.push(undo);
+
       return written;
     };
   }

package/src/boot/install.ts

@@ -21,6 +21,7 @@ import type { Diagnostic } from '../diagnostic.js';
 import { HandlerFacade } from '../dispatch/HandlerFacade.js';
 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 { contractsKeyOf, facadeKeyOf } from '../wire/Facade.js';
@@ -307,7 +308,7 @@ function registerProviders(
     // 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()) {
+    for (const wrapper of chain.slice(0, -1).reverse()) {
       const deps = wrapper.deps.map((dep) => (dep === port ? inner : dep));
       inner = nameOf(wrapper);
       scope.register(inner, wrapper.ctor, { deps });
@@ -456,88 +457,51 @@ function buildFacadeInto(
   ));
 }
 
-export async function installFrond(frond: FrondDescriptor, assembly: Assembly): Promise<void> {
-  const {
-    container, routeRegistry, emissions, dispatcher, localDispatcher, effectiveByKey,
-    boundPorts, refused, operationModel, entityByName, frondOf, contractsOf, getMiddlewares, use,
-    log, options,
-  } = assembly;
-
-  // Declared remote: keep the scanned metadata (bridges route with it),
-  // 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 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);
-      effectiveByKey.set(key, operations);
-      emissions.note(contractsOf(operations), key);
-
-    }
-    return;
+/** Its facades answer elsewhere, but what they LISTEN to is read here, and the bridges route with it. */
+function noteRemoteFrond(frond: FrondDescriptor, { operationModel, effectiveByKey, emissions, contractsOf, log }: Assembly): void {
+  log.child(frond.name).info('declared remote — not hosted locally');
+  for (const handler of frond.handlers) {
+    const key = facadeKeyOf(handler.address, handler.surface);
+    const operations = operationModel.forHandler(handler);
+    effectiveByKey.set(key, operations);
+    emissions.note(contractsOf(operations), key);
   }
-  // A child hangs off its parent, so everything the parent registered answers here too and
-  // nothing else has to know: `ScopeContainer.resolve` already walks up. The boot installs
-  // parents first, which is what makes the key below resolvable.
-  const above = frond.extends ? container.resolve<Container>(`frond:${frond.extends}`) : container;
-  const scope = above.createScope();
-  const frondLog = log.child(frond.name);
-  // The frond's own voice, a child of the APP logger and never of `log` — which is the
-  // boot's, so a service's line would have claimed `boot:` long after the boot was over.
-  scope.registerValue('Logger', container.resolve<Logger>('Logger').child(frond.name));
-
-  // `reads:` is what makes a cross-source reader exist here, and the list IS its
-  // environment — a source holding none of these is never opened. Registered under
-  // the type's own name, which is the key `depKeyOf` already derives for a plain
-  // parameter: `constructor(private reads: Reads)` and nothing else to say.
-  // Declaring `reads:` with nothing to build the reader is a boot that ignores a
-  // clause: the handler asking for `Reads` then dies at its first call, on a
-  // container message that names neither the clause nor what is missing.
-  await registerReads(frond, scope, entityByName, options.sourcesFactory, frondLog);
+}
 
-  // 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.
+/**
+ * Who owns what, and the rule that makes owning mean something — refused before anything is
+ * registered, so a bad line is named here rather than by the container.
+ */
+function ownershipOf(frond: FrondDescriptor, { entityByName, refused }: Assembly): Map<string, string> {
   sharedNames(frond, refused);
+  refuseArityDrift(frond, refused);
   const owners = ownersOf(frond.providers, frond.name, refused);
   storageInUserCode(frond, owners, (entity) => entityByName.has(entity), refused);
   crudOnOwned(frond, owners, refused);
 
-  const declared = registerProviders(frond, scope, options.ports, boundPorts, refused, frondLog);
-  // An ancestor's links stand OUTSIDE this frond's own, the order `wrapping` reads — and
-  // like a middleware, a link cannot be inherited through a container key, since a seam has
-  // none: its realization is built rather than resolved.
-  const seams = inheritedSeams(frond, assembly.seamsOf, declared);
-  assembly.seamsOf.set(frond.name, seams);
+  return owners;
+}
 
-  // Register Storage for each entity — PascalCase type name (e.g. 'PostStorage')
-  // When a handler declares Crud(Entity, Output), scope the storage via .output(Output)
-  registerStorages(frond, assembly, scope, seams, owners, frondLog);
+/** A frame is read from the same `deps` every port is: asking for one IS declaring it. */
+function registerFramesOf(frond: FrondDescriptor, assembly: Assembly, scope: Container, frondLog: Logger): void {
+  const { entityByName, frondOf, options, hosting, refused } = assembly;
+  const wanted = [...frond.handlers, ...frond.providers, ...frond.presenters, ...frond.collectors]
+    .flatMap((declared) => declared.deps.map((key) => ({ key, filePath: declared.filePath })));
+
+  registerFrames(scope, wanted, frond.providers, {
+    entityByName,
+    frondOf,
+    hostedHere: (name) => !(options.remotes && name in options.remotes),
+    storageFactory: options.storageFactory,
+    sourceOf: options.sourceOf,
+    transacts: options.transacts,
+    transacted: options.transacted,
+    hosting,
+    log: frondLog,
+  }, refused);
+}
 
-  // Frames, after the ORMs and before anything that may ask for one. A frame is read
-  // from the same `deps` every other port is read from — asking for it IS declaring it,
-  // so nothing is registered for a frame nobody wants.
-  registerFrames(
-    scope,
-    [...frond.handlers, ...frond.providers, ...frond.presenters, ...frond.collectors]
-      .flatMap((d) => d.deps.map((key) => ({ key, filePath: d.filePath }))),
-    frond.providers,
-    {
-      entityByName,
-      frondOf,
-      hostedHere: (name) => !(options.remotes && name in options.remotes),
-      storageFactory: options.storageFactory,
-      sourceOf: options.sourceOf,
-      transacts: options.transacts,
-      transacted: options.transacted,
-      hosting: assembly.hosting,
-      log: frondLog,
-    },
-    refused,
-  );
-
-  // Register presenters in scope — PascalCase type name (e.g. 'PostPresenter')
-  const presenterMap = new Map(frond.presenters.map((p) => [p.entityName, p]));
+function registerPresenters(frond: FrondDescriptor, scope: Container, frondLog: Logger): Map<string, PresenterEntry> {
   for (const presenter of frond.presenters) {
     scope.register(presenterKeyOf(presenter.entityName), presenter.ctor, { deps: presenter.deps });
   }
@@ -545,104 +509,117 @@ export async function installFrond(frond: FrondDescriptor, assembly: Assembly):
     frondLog.debug(`${frond.presenters.length} presenter(s): ${frond.presenters.map((p) => p.entityName).join(', ')}`);
   }
 
-  // Register collectors in scope — PascalCase type name (e.g. 'UserCollector')
-  const collectorTypeNames = new Set(frond.collectors.map((c) => c.typeName));
+  return new Map(frond.presenters.map((presenter) => [presenter.entityName, presenter]));
+}
+
+function registerCollectors(frond: FrondDescriptor, scope: Container, frondLog: Logger): Set<string> {
   for (const collector of frond.collectors) {
-    const key = collectorKeyOf(collector.typeName);
-    scope.register(key, collector.ctor, { deps: collector.deps });
+    scope.register(collectorKeyOf(collector.typeName), collector.ctor, { deps: collector.deps });
   }
   if (frond.collectors.length > 0) {
     frondLog.debug(`${frond.collectors.length} collector(s): ${frond.collectors.map((c) => c.typeName).join(', ')}`);
   }
 
-  // Register middlewares in scope, then take them on. Resolved per call and never here:
-  // a middleware asking for something request-scoped would otherwise be handed the one
-  // instance the boot built — the same reason `getMiddlewares` is read at call time.
-  registerMiddlewares(frond, scope, assembly, frondLog);
-
-  // Build handler facades → registered in ROOT container (public contract)
-  const defaultHandlers = frond.handlers.filter((h) => !h.surface);
-  const surfaceHandlers = frond.handlers.filter((h) => h.surface);
-  const defaultHandlerMap = new Map(defaultHandlers.map((h) => [h.address, h]));
+  return new Set(frond.collectors.map((collector) => collector.typeName));
+}
 
-  const building: Building = { frond, assembly, scope, collectorTypeNames, presenterMap, frondLog };
-  const buildFacade = (
-    entity: EntityEntry | undefined,
-    handler: HandlerEntry,
-    targetScope: Container,
-    facadeKey: string,
-  ) => buildFacadeInto(building, entity, handler, targetScope, facadeKey);
-
-  // A presenter is about an entity — computed fields sit on a shape — so this walks
-  // entities. Exposing the instance lazily; the bridge resolves it on first access.
-  exposePresenters(frond, presenterMap, container, scope);
+function sayFacade(building: Building, facadeKey: string, entity: EntityEntry | undefined): void {
+  const operations = Object.keys(building.assembly.container.resolve(facadeKey) as object).join(', ');
+  building.frondLog.debug(`${facadeKey} [${operations}]`
+    + (entity ? '' : ' — no entity of that name: no storage, no projection, no presenter'));
+}
 
-  // A facade is about a handler, so this walks HANDLERS. It walked entities before,
-  // which made an entity a precondition for being callable at all: a handler naming
-  // none was scanned, then never built, and nothing said so.
-  for (const handler of defaultHandlers) {
-    // Two ways to know the subject, and the explicit one wins: `Crud(Item)` names the
-    // entity it was built on, whatever the handler is called. Otherwise the handler's
-    // own name is the only thing pointing at one — and pointing at nothing is legal.
-    //
-    // By NAME, not by identity: the scanner loads an entity through its own loader and
-    // the handler imports it through the runtime's, so the same class arrives as two
-    // objects. `===` compares module instances, which is not the question being asked.
+/**
+ * A facade is about a handler, so this walks HANDLERS — pointing at no entity is legal. The
+ * subject is `Crud(Item)`'s when it names one, the handler's own name otherwise, compared by
+ * NAME: the scanner and the runtime load one class as two objects.
+ */
+function buildDefaultFacades(building: Building, handlers: readonly HandlerEntry[]): void {
+  for (const handler of handlers) {
     const crudTarget = targetOf(handler.ctor);
     const subject = crudTarget?.name ? lowerFirst(crudTarget.name) : handler.address;
-    const entity = frond.entities.find((e) => e.name === subject);
+    const entity = building.frond.entities.find((e) => e.name === subject);
     const facadeKey = facadeKeyOf(handler.address);
-    buildFacade(entity, handler, scope, facadeKey);
-    frondLog.debug(`${facadeKey} [${Object.keys(container.resolve(facadeKey) as object).join(', ')}]`
-      + (entity ? '' : ' — no entity of that name: no storage, no projection, no presenter'));
+    buildFacadeInto(building, entity, handler, building.scope, facadeKey);
+    sayFacade(building, facadeKey, entity);
   }
+}
 
-  // The dual, and it stays: a shape that declares no operation answers nothing. Said
-  // once per entity rather than deduced from a silence.
-  for (const entity of frond.entities) {
-    if (!defaultHandlerMap.has(entity.name)) {
-      frondLog.debug(`${entity.name} — entity only, no handler: exposes nothing`);
-    }
+/** A shape that declares no operation answers nothing — said once per entity rather than deduced from a silence. */
+function sayUnhandledEntities(building: Building, handlers: readonly HandlerEntry[]): void {
+  const handled = new Set(handlers.map((handler) => handler.address));
+  for (const entity of building.frond.entities) {
+    if (!handled.has(entity.name)) building.frondLog.debug(`${entity.name} — entity only, no handler: exposes nothing`);
   }
+}
 
-  // Surface handlers — create sub-scope per surface handler with scoped storage
-  //
-  // 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 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);
-    const surfaceScope = scope.createScope();
-
-    // 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 facade at all once the façade stopped spelling the storage.
-    if (entity) registerSurfaceStorage(entity, handler, surfaceScope, assembly, frondLog);
+/**
+ * One sub-scope per surface handler, holding the storage its view scopes — under the REPOSITORY
+ * key a Crud handler asks for. Pointing at no entity is legal here too: one rule, both surfaces.
+ */
+function buildSurfaceFacades(building: Building, handlers: readonly HandlerEntry[]): void {
+  for (const handler of handlers) {
+    const entity = building.frond.entities.find((e) => e.name === handler.address);
+    const surfaceScope = building.scope.createScope();
+    if (entity) registerSurfaceStorage(entity, handler, surfaceScope, building.assembly, building.frondLog);
 
     const facadeKey = facadeKeyOf(handler.address, handler.surface);
-    buildFacade(entity, handler, surfaceScope, facadeKey);
-    frondLog.debug(`${facadeKey} [${Object.keys(container.resolve(facadeKey) as object).join(', ')}]`
-      + (entity ? '' : ' — no entity of that name: no storage, no projection, no presenter'));
+    buildFacadeInto(building, entity, handler, surfaceScope, facadeKey);
+    sayFacade(building, facadeKey, entity);
   }
+}
 
-  // A named surface is closed, so what it contains is a fact worth stating.
-  // Saying it at boot is the difference between a rule and a rule you can
-  // check: an entity you meant to serve and never wrote a handler for is
-  // absent HERE, in one line, instead of being discovered missing later.
-  const surfaceNames = [...new Set(surfaceHandlers.map((h) => h.surface as string))].sort();
+/** A named surface is closed, so what it serves — and what it leaves out — is said at boot, in one line. */
+function sayWhatSurfacesServe(frond: FrondDescriptor, handlers: readonly HandlerEntry[], frondLog: Logger): void {
+  const surfaceNames = [...new Set(handlers.map((h) => h.surface as string))].sort();
   for (const surfaceName of surfaceNames) {
-    const served = surfaceHandlers
-      .filter((h) => h.surface === surfaceName)
-      .map((h) => h.address)
-      .sort();
+    const served = handlers.filter((h) => h.surface === surfaceName).map((h) => h.address).sort();
     const absent = frond.entities.map((e) => e.name).filter((n) => !served.includes(n));
     frondLog.info(
       `surface '${surfaceName}' — ${served.length} entit${served.length === 1 ? 'y' : 'ies'}: ${served.join(', ')}` +
       (absent.length > 0 ? ` (not served: ${absent.join(', ')})` : ''),
     );
   }
+}
+
+export async function installFrond(frond: FrondDescriptor, assembly: Assembly): Promise<void> {
+  const { container, entityByName, options, log } = assembly;
+
+  if (options.remotes && frond.name in options.remotes) {
+    noteRemoteFrond(frond, assembly);
+
+    return;
+  }
+
+  // A child hangs off its parent, so what the parent registered answers here too — parents are installed first.
+  const above = frond.extends ? container.resolve<Container>(`frond:${frond.extends}`) : container;
+  const scope = above.createScope();
+  const frondLog = log.child(frond.name);
+  // A child of the APP logger, never of the boot's, whose `boot:` would outlive the boot.
+  scope.registerValue('Logger', container.resolve<Logger>('Logger').child(frond.name));
+
+  await registerReads(frond, scope, entityByName, options.sourcesFactory, frondLog);
+  const owners = ownershipOf(frond, assembly);
+
+  const declared = registerProviders(frond, scope, options.ports, assembly.boundPorts, assembly.refused, frondLog);
+  // An ancestor's links stand OUTSIDE this frond's own; a seam has no container key to inherit through.
+  const seams = inheritedSeams(frond, assembly.seamsOf, declared);
+  assembly.seamsOf.set(frond.name, seams);
+  registerStorages(frond, assembly, scope, seams, owners, frondLog);
+  registerFramesOf(frond, assembly, scope, frondLog);
+
+  const presenterMap = registerPresenters(frond, scope, frondLog);
+  const collectorTypeNames = registerCollectors(frond, scope, frondLog);
+  registerMiddlewares(frond, scope, assembly, frondLog);
+  exposePresenters(frond, presenterMap, container, scope);
+
+  const building: Building = { frond, assembly, scope, collectorTypeNames, presenterMap, frondLog };
+  const defaultHandlers = frond.handlers.filter((h) => !h.surface);
+  const surfaceHandlers = frond.handlers.filter((h) => h.surface);
+  buildDefaultFacades(building, defaultHandlers);
+  sayUnhandledEntities(building, defaultHandlers);
+  buildSurfaceFacades(building, surfaceHandlers);
+  sayWhatSurfacesServe(frond, surfaceHandlers, frondLog);
 
   container.registerValue(`frond:${frond.name}`, scope);
   frondLog.info(`registered — ${frond.entities.length} entities, ${frond.handlers.length} handlers, ${frond.seeds.length} seeds`);

package/src/boot/ownership.ts

@@ -80,6 +80,7 @@ function builtOn(ctor: unknown): string[] {
   const owned = ownedBy(ctor);
   if (owned.length > 0) return owned.map((e) => lowerFirst((e as { name: string }).name));
   const target = targetOf(ctor) as { name?: string } | undefined;
+
   return target?.name ? [lowerFirst(target.name)] : [];
 }
 

package/src/boot/relations.ts

@@ -4,7 +4,8 @@ import type { Dependent } from '../dispatch/Dependent.js';
 import type { RelationCheck } from '../dispatch/RelationCheck.js';
 import type { Hosting } from './Hosting.js';
 import type { Diagnostic } from '../diagnostic.js';
-import type { Releasing, Rows } from '../dispatch/Release.js';
+import type { Releasing } from '../dispatch/Release.js';
+import type { EntityEntry } from '../descriptor/EntityEntry.js';
 
 /**
  * Does a foreign key hold this reference? Both sides in ONE source that keeps relations — two
@@ -34,7 +35,7 @@ function referencesTo(target: string, hosting: Hosting): { entity: string; field
   for (const [entity, schema] of hosting.entities()) {
     for (const [field, declared] of Object.entries(schema.getFields())) {
       const role = Role.of(declared);
-      if (role.isReference && role.target?.name && lowerFirst(role.target.name) === target) {
+      if (role.isReference() && role.target?.name && lowerFirst(role.target.name) === target) {
         found.push({ entity, field, role });
       }
     }
@@ -43,11 +44,6 @@ function referencesTo(target: string, hosting: Hosting): { entity: string; field
   return found;
 }
 
-/** What a target's storage has to answer for a key set to be judged in one read. */
-interface ByKeys {
-  findByKeys(keys: readonly string[]): Promise<Map<string, unknown>>;
-}
-
 /**
  * The references a foreign key cannot hold, each as a read the guard makes before the write.
  *
@@ -58,7 +54,7 @@ export function heldBy(entity: SchemaView, name: string, hosting: Hosting): Rela
 
   for (const [field, declared] of Object.entries(entity.getFields())) {
     const role = Role.of(declared);
-    if (!role.isReference || !role.target?.name) continue;
+    if (!role.isReference() || !role.target?.name) continue;
 
     const target = lowerFirst(role.target.name);
     if (keyed(name, target, hosting)) continue;
@@ -67,7 +63,7 @@ export function heldBy(entity: SchemaView, name: string, hosting: Hosting): Rela
       field,
       target,
       missing: async (keys) => {
-        const storage = hosting.storageOf(target) as ByKeys | undefined;
+        const storage = hosting.storageOf(target);
         // Nothing here holds those rows — the process that does answers the same reading,
         // so the question crosses rather than being given up on.
         if (!storage) return hosting.peerOf(target)?.missing(target, keys) ?? [];
@@ -122,6 +118,42 @@ export function refuseUnwritableNull(entity: SchemaView, name: string, filePath:
   return refused;
 }
 
+/**
+ * A `many()` whose target declares no `ref()` back. The key lives on the far row, so a
+ * relation neither side states can never be filled: SQL emits no column, GraphQL drops the
+ * field when it finds no reverse key, and nothing says why.
+ *
+ * Asked once every frond is installed, since the target may belong to another one — and left
+ * alone when it answers elsewhere, where its fields are declared and cannot be read here.
+ */
+export function unpaired(entities: readonly EntityEntry[], hosting: Hosting): Diagnostic[] {
+  const refused: Diagnostic[] = [];
+
+  for (const entry of entities) {
+    for (const [field, declared] of Object.entries(entry.entityClass.getFields())) {
+      const role = Role.of(declared);
+      const target = role.isCollection() ? role.target?.name : undefined;
+      if (!target || !hosting.hostedHere(lowerFirst(target))) continue;
+
+      const held = referencesTo(lowerFirst(entry.name), hosting)
+        .some((one) => one.entity === lowerFirst(target));
+      if (held) continue;
+
+      refused.push({
+        severity: 'blocking',
+        code: 'many-without-reference',
+        filePath: entry.filePath,
+        subject: `${entry.name}.${field}`,
+        message: `${entry.entityClass.name}.${field} states many(${target}), and no field of `
+          + `${target} references ${entry.entityClass.name}: the relation is declared on neither `
+          + `side, so nothing can fill it. Declare the ref() on ${target}.`,
+      });
+    }
+  }
+
+  return refused;
+}
+
 /** The checks nothing in this process can answer — asked once every frond has registered. */
 export function unheldAmong(checks: readonly RelationCheck[], hosting: Hosting): string[] {
   return checks
@@ -139,7 +171,7 @@ export function unheldAmong(checks: readonly RelationCheck[], hosting: Hosting):
 export function releasing(hosting: Hosting): Releasing {
   return {
     dependentsOf: (entity) => dependentsOf(entity, hosting),
-    rowsOf: (entity) => hosting.storageOf(entity) as Rows | undefined,
+    rowsOf: (entity) => hosting.storageOf(entity),
     schemaOf: (entity) => hosting.entities().get(entity),
     peers: () => hosting.peers(),
     journal: (entity) => hosting.journal(entity),

package/src/boot/remote.ts

@@ -54,6 +54,7 @@ export function createRemoteRouter(
         transports.set(url, transport);
         try {
           const answer = await transport({ entity: RPC_ENTITY, 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.
           return { label, url, transport, answer };

package/src/boot/seed.ts

@@ -47,7 +47,7 @@ function whatEachWaitsFor(
     for (const entity of frond.entities) {
       const targets = new Set<string>();
       for (const field of Object.values(entity.entityClass.getFields())) {
-        if (!Role.of(field).isReference) continue;
+        if (!Role.of(field).isReference()) continue;
         const target = (Role.of(field).target as { name?: string }).name?.toLowerCase();
         if (target && target !== entity.name.toLowerCase()) targets.add(target);
       }
@@ -67,7 +67,7 @@ function whatEachWaitsFor(
 /** Where a seed writes, and what it may skip — resolved per entity. */
 interface SeedFacade {
   list(): Promise<unknown[]>;
-  write(item: unknown): Promise<unknown>;
+  write(item: Record<string, unknown>): Promise<unknown>;
 }
 
 /**
@@ -126,9 +126,7 @@ function facadeFor(app: App, entityName: string): SeedFacade | undefined {
     };
   }
 
-  const storage = app.storageFor(entityName) as
-    | { list: () => Promise<unknown[]>; create: (input: unknown) => Promise<unknown> }
-    | undefined;
+  const storage = app.storageFor(entityName);
   if (!storage) return undefined;
 
   return { list: () => storage.list(), write: (item) => storage.create(item) };

package/src/boot/statement-drift.ts

@@ -41,3 +41,28 @@ export function statementDrift(frond: FrondDescriptor, handler: HandlerEntry): D
 
   return found;
 }
+
+/**
+ * A contract with no method under its name. The scan cannot produce one; a declaration can, and
+ * its first call used to fail as `instance[method] is not a function` — a server error for what
+ * is a typo in the declaration.
+ */
+export function unansweredOperations(
+  frond: FrondDescriptor,
+  handler: HandlerEntry,
+  names: Iterable<string>,
+): Diagnostic[] {
+  const prototype = handler.ctor.prototype as Record<string, unknown>;
+
+  return [...names]
+    .filter((name) => typeof prototype[name] !== 'function')
+    .map((name) => ({
+      severity: 'blocking',
+      code: 'operation-without-method',
+      filePath: handler.filePath,
+      frond: frond.name,
+      subject: `${handler.ctor.name}.${name}`,
+      message: `${handler.ctor.name}.${name} is declared as an operation, and ${handler.ctor.name} `
+        + 'has no method of that name — its first call would fail as a server error.',
+    }));
+}

package/src/boot/together.ts

@@ -154,13 +154,16 @@ async function inScope<R>(
     const storages = members.entities.map((member) => {
       const storage = wrap(factory(member.schema, member.name), member.name, member.schema);
       scope.registerValue(storageKeyOf(member.name), storage);
+
       return storage;
     });
     // Providers after every storage is in place: one may depend on another member's.
     const built = members.providers.map((provider) => {
       scope.register(provider.ctor.name, provider.ctor, { deps: provider.deps });
+
       return scope.resolve(provider.ctor.name);
     });
+
     return await fn(storages, built);
   } finally {
     await scope.dispose();

package/src/builtin/Carry.ts

@@ -24,6 +24,7 @@ export class Carry {
       try {
         this.take(record);
       } catch { /* announcing never breaks logging, for the same reason a sink does not */ }
+
       return;
     }
     this.held.push(record);

package/src/builtin/Logger.ts

@@ -12,6 +12,7 @@ let threshold: number = LEVELS[envLevel() ?? 'info'];
 /** The level the PROCESS was started with. */
 export function envLevel(): LogLevel | undefined {
   const raw = typeof process === 'undefined' ? undefined : process.env.FOUGERE_LOG_LEVEL;
+
   return raw !== undefined && raw in LEVELS ? (raw as LogLevel) : undefined;
 }
 
@@ -51,8 +52,10 @@ function supportsColor(): boolean {
   if (typeof process !== 'undefined') {
     if (process.env.NO_COLOR) return false;
     if (process.env.FORCE_COLOR === '1') return true;
+
     return process.stdout?.isTTY === true;
   }
+
   return false;
 }
 
@@ -62,6 +65,7 @@ function stamp(at: number | Date): string {
   const m = String(d.getMinutes()).padStart(2, '0');
   const s = String(d.getSeconds()).padStart(2, '0');
   const ms = String(d.getMilliseconds()).padStart(3, '0');
+
   return `${h}:${m}:${s}.${ms}`;
 }
 
@@ -92,7 +96,7 @@ export class Logger {
       level: level as LogRecord['level'], name: this.name, message: msg, args, at: Date.now(),
     };
 
-    this.carry?.push(record);
+    this.carry?.push({ ...record, args: args.map(objectOf) });
 
     // The console ALWAYS, whoever else took the line. Skipping it once a destination
     // existed made `calls()` — a devtools ring that prints nothing — silence the
@@ -103,6 +107,10 @@ export class Logger {
   }
 }
 
+/** A line travels as a fact, where `args` states `json()` — an object. */
+const objectOf = (arg: unknown): object =>
+  typeof arg === 'object' && arg !== null && !Array.isArray(arg) ? arg : { value: arg };
+
 export function formatted(
   record: Rendered,
   color = supportsColor(),