@fougere/core 0.12.0-alpha.0 → 0.12.2-alpha.0

package/src/EffectiveOperationModel.ts

@@ -1,5 +1,5 @@
 import { lowerFirst, type SchemaView } from '@fougere/schema';
-import { statementDrift } from './boot/statement-drift.js';
+import { statementDrift, unansweredOperations } from './boot/statement-drift.js';
 import { reachedBy, servedBy } from './boot/declared.js';
 import { computeBindingPlan, type BindingPlan } from './wire/binding.js';
 import { targetOf } from './prefab/prefab.js';
@@ -111,12 +111,32 @@ export function resolveEffectiveOperations(
       // A statement wins over the scan on purpose; saying so out loud is what keeps the
       // win from hiding a rename. Compared here, where both readings are in hand.
       resolutionDiagnostics.push(...statementDrift(frond, handler));
+      resolutionDiagnostics.push(...unansweredOperations(frond, handler, contracts.keys()));
 
       for (const [name, rawContract] of contracts) {
         const subject = `${handler.ctor.name}.${name}`;
         const contract = normalizeBinding(rawContract, handler, frond, name, resolutionDiagnostics);
         if (!contract) continue;
 
+        // An operation answers DATA — what JSON keeps. A DECLARED output is converted by its
+        // fields, so `created()` leaves as an ISO string and nothing is asked of it here; an
+        // undeclared one has nothing to convert it, so it must already be data. Measured
+        // 2026-09-18: `{ at: new Date(0) }` reaches a local caller as a `Date` and a remote one
+        // as a string, and an object carrying methods loses them on both sides, differently.
+        if (!contract.output && contract.signature?.notData) {
+          resolutionDiagnostics.push({
+            severity: 'blocking',
+            code: 'operation-output-not-data',
+            filePath: handler.filePath,
+            frond: frond.name,
+            subject,
+            message: `${subject}() answers ${contract.signature.notData}, which carries methods.\n`
+              + '  An operation answers data — what JSON keeps.\n'
+              + '  Declare the output as an entity, whose fields convert it, or answer what it produces.',
+          });
+          continue;
+        }
+
         const override = frond.operationsOverrides?.[name];
         const inference = inferOperationKind(name);
         const inferredKinds = new Set<OperationKind>();
@@ -155,6 +175,7 @@ export function resolveEffectiveOperations(
           const undefinable = binding.optional
             || param?.optional === true
             || param?.type.undefined === true;
+
           return {
             position,
             name: param?.name ?? binding.name,
@@ -219,6 +240,7 @@ export function resolveEffectiveOperations(
           collectors: parameters.flatMap((parameter) => {
             if (parameter.binding.source.kind !== 'collector') return [];
             const collector = collectorsByType.get(parameter.binding.source.typeName)?.[0];
+
             return collector ? [{
               parameter: parameter.name,
               typeName: collector.typeName,
@@ -260,6 +282,7 @@ export function resolveEffectiveOperations(
   }
 
   const resolution = uniqueDiagnostics(resolutionDiagnostics);
+
   return new EffectiveOperationModel(
     operations,
     uniqueDiagnostics([...scanDiagnostics, ...resolution]),
@@ -275,6 +298,7 @@ function groupedCollectors(collectors: readonly CollectorEntry[]): Map<string, C
     sameName.push(collector);
     grouped.set(collector.typeName, sameName);
   }
+
   return grouped;
 }
 
@@ -296,6 +320,7 @@ function normalizeBinding(
       subject: `${handler.ctor.name}.${name}`,
       message: `${handler.ctor.name}.${name} declares ${params.length} parameter(s) and has no binding plan.`,
     });
+
     return undefined;
   }
   if (params.length === 0) return { ...contract, binding: contract.binding };
@@ -322,8 +347,10 @@ function normalizeBinding(
         + `${invalid.length ? `Invalid: ${invalid.map((param) => param.name).join(', ')}. ` : ''}`
         + `${extras.length ? `Unknown: ${extras.join(', ')}.` : ''}`,
     });
+
     return undefined;
   }
+
   return {
     ...contract,
     binding: params.map((param) => byName.get(param.name)![0]!),
@@ -368,6 +395,7 @@ function validateProvenance(
             + `${matches.map((parameter) => `${parameter.name}: ${parameter.type ?? 'unknown'}`).join('; ')} `
             + 'all match the resolved input contract. Declare an explicit binding plan.',
         });
+
         return false;
       }
       if (matches.length === 1) inferredBody.add(matches[0]!);
@@ -429,6 +457,7 @@ function validateProvenance(
         + 'local collector or resolved input schema. Declare an explicit binding.',
     });
   }
+
   return valid;
 }
 
@@ -439,6 +468,7 @@ function structural(type: TypeRef | undefined): boolean {
 function schemaMatches(schema: SchemaView, type: TypeRef | undefined): boolean {
   const names = new Set([schema.name, schema.derivation?.sourceName].filter(Boolean));
   if (type?.name && names.has(type.name)) return true;
+
   return type?.generics?.some((generic) => generic.name && names.has(generic.name)) ?? false;
 }
 
@@ -462,6 +492,7 @@ function implementationOf(
       message: `Operation ${handler.ctor.name}.${name} names handler '${override?.handlerName}', `
         + `but ${candidates.length} matching handlers were found.`,
     });
+
     return undefined;
   }
   const implementation = candidates[0]!;
@@ -479,8 +510,10 @@ function implementationOf(
       message: `Operation ${handler.ctor.name}.${name} resolves to `
         + `${implementation.ctor.name}.${method}, but that method does not exist.`,
     });
+
     return undefined;
   }
+
   return {
     className: implementation.ctor.name,
     address: implementation.address,
@@ -505,6 +538,7 @@ function effectiveOutput(
   const target = targetOf(handler.ctor) as { name?: string } | undefined;
   const address = target?.name ? lowerFirst(target.name) : handler.address;
   const entity = frond.entities.find((candidate) => candidate.name === address);
+
   return { ...(entity ? { schema: entity.entityClass } : {}), closed: false };
 }
 
@@ -513,6 +547,7 @@ function exposedAdapters(
   adapters: Record<string, boolean | undefined> | undefined,
 ): string[] {
   if (handler.exposed === false && !handler.surface) return [];
+
   return Object.entries(adapters ?? {})
     .filter(([, enabled]) => enabled === true)
     .map(([adapter]) => adapter)
@@ -521,10 +556,12 @@ function exposedAdapters(
 
 function uniqueDiagnostics(diagnostics: readonly Diagnostic[]): Diagnostic[] {
   const seen = new Set<string>();
+
   return diagnostics.filter((diagnostic) => {
     const key = [diagnostic.code, diagnostic.filePath, diagnostic.subject, diagnostic.message].join('\0');
     if (seen.has(key)) return false;
     seen.add(key);
+
     return true;
   });
 }

package/src/FougereConfig.ts

@@ -47,9 +47,11 @@ async function loadConfigFrom(dir: string, fresh?: boolean): Promise<FougereConf
       // return the config already in force. The loader owns its own cache, so it is the
       // one told; the old module stays in memory, re-reading being for a change.
       const mod = await loader(path, fresh ? { fresh } : undefined);
+
       return ((mod as { default?: FougereConfig }).default ?? mod) as FougereConfig;
     }
   }
+
   return {};
 }
 
@@ -92,5 +94,6 @@ function mergeGlobal(base: FougereConfig, override: Partial<FougereConfig>): Fou
 export async function loadCascadedConfig(workspaceRoot: string, appRoot: string): Promise<FougereConfig> {
   const base = await loadConfig(workspaceRoot);
   if (resolve(workspaceRoot) === resolve(appRoot)) return base;
+
   return mergeGlobal(base, await loadConfig(appRoot));
 }

package/src/FrondConfig.ts

@@ -44,8 +44,10 @@ export async function loadFrondConfig(frondPath: string): Promise<FrondConfig |
     const path = resolve(frondPath, file);
     if (existsSync(path)) {
       const mod = await import(path);
+
       return mod.default ?? mod;
     }
   }
+
   return undefined;
 }

package/src/Source.ts

@@ -7,10 +7,10 @@ import type { SourceConfig } from './SourceConfig.js';
 /** Whether an entity asks for one, anywhere but on its key. */
 export function declares(schema: SchemaView, constraint: Constraint): boolean {
   const fields = Object.values(schema.getFields());
-  if (constraint === 'relation') return fields.some((field) => Role.of(field).isReference);
+  if (constraint === 'relation') return fields.some((field) => Role.of(field).isReference());
   if ((schema.getUnique() ?? []).length > 0) return true;
 
-  return fields.some((field) => Role.of(field).isUnique);
+  return fields.some((field) => Role.of(field).isUnique());
 }
 
 /**

package/src/boot/AppLifecycle.ts

@@ -12,6 +12,7 @@ export class AppLifecycle {
       if (at === -1) this.members.push(extension);
       else this.members[at] = extension;
     }
+
     return this;
   }
 

package/src/boot/Emissions.ts

@@ -318,6 +318,7 @@ export class Emissions {
    */
   private stamped(fact: string, raw: unknown): unknown {
     const shape = this.shapes.get(fact);
+
     return shape && raw !== null && typeof raw === 'object' && !Array.isArray(raw)
       ? applyCreate(shape.getFields(), raw as Record<string, unknown>)
       : raw;
@@ -337,6 +338,7 @@ export class Emissions {
     const listeners = this.subscribers.get(fact) ?? [];
     if (listeners.length === 0) {
       this.log.debug(`${fact} — nobody listens in this process`);
+
       return [];
     }
 
@@ -350,6 +352,7 @@ export class Emissions {
         } catch (cause) {
           throw new Error(`${fact} → ${facade} could not be reached`, { cause });
         }
+
         return handler[op]({ ...Invocation.empty, input: payload });
       }),
     }));
@@ -359,6 +362,7 @@ export class Emissions {
   private describeRefusal(fact: string, cause: unknown): string | undefined {
     const refusals = validationErrorsOf(cause);
     if (!refusals?.length) return undefined;
+
     return `refused the shape — ${refusals.map((d) => `${dotted(d.path)}: ${d.message}`).join(', ')}.`
       + ` If '${fact}' gained a field, this copy is older than the sender's: re-run \`fougere sync\`.`;
   }

package/src/boot/ambient.als.ts

@@ -17,12 +17,14 @@ export const ambient: Ambient = {
         + `are ONE frame — declare a single Together naming every member.`,
       ));
     }
+
     return frame.run(key, fn);
   },
 
   beforeAnnounce(fact: string): Promise<void> {
     const open = frame.getStore();
     if (open === undefined) return Promise.resolve();
+
     return Promise.reject(new Error(
       `${fact} cannot be announced inside Together<[…]> (${open}): announcing is dispatch, `
       + `so subscribers and the carrier would have it while these writes can still be taken `

package/src/boot/apply.ts

@@ -40,5 +40,6 @@ export function applyConfig(next: FougereConfig, inForce?: FougereConfig): Confi
       pending.push(key);
     }
   }
+
   return { applied, pending };
 }

package/src/boot/arity.ts

@@ -0,0 +1,42 @@
+import type { Diagnostic } from '../diagnostic.js';
+import type { FrondDescriptor } from '../descriptor/FrondDescriptor.js';
+
+interface Constructed {
+  ctor: { name: string; length: number };
+  deps: string[];
+  filePath: string;
+}
+
+/**
+ * What the container hands a constructor is `deps`, one argument per key and in order — so a
+ * constructor asking for more is handed `undefined`. The scan reads `deps` off the signature and
+ * cannot miss; a frond declared by hand can, and `Function.length` is the one thing a
+ * constructor says about itself once the types are gone.
+ *
+ * `length` is a floor and never a count: a class that writes no constructor inherits
+ * `(...args) => super(...args)`, which is 0, while the scan read its parent's dependencies.
+ */
+export function refuseArityDrift(frond: FrondDescriptor, refused: Diagnostic[]): void {
+  const constructed: Constructed[] = [
+    ...frond.handlers,
+    ...frond.presenters,
+    ...frond.collectors,
+    ...frond.providers,
+    ...frond.middlewares,
+  ];
+
+  for (const { ctor, deps, filePath } of constructed) {
+    if (ctor.length <= deps.length) continue;
+
+    refused.push({
+      severity: 'blocking',
+      code: 'constructor-arity',
+      filePath,
+      frond: frond.name,
+      subject: ctor.name,
+      message: `${ctor.name}'s constructor takes ${ctor.length} parameter(s) and ${deps.length} `
+        + `dependenc${deps.length === 1 ? 'y is' : 'ies are'} declared (${deps.join(', ') || 'none'}) — `
+        + 'the rest would be handed `undefined`.',
+    });
+  }
+}

package/src/boot/bootstrap.ts

@@ -7,7 +7,7 @@ import { hostedBy } from './hosted.js';
 import { nestingOf, parentsFirst } from './nesting.js';
 import type { Fronds } from '../descriptor/Fronds.js';
 import { installFrond, type Assembly } from './install.js';
-import { dependentsOf, releasing, unfinishable, unheldAmong } from './relations.js';
+import { dependentsOf, releasing, unfinishable, unheldAmong, unpaired } from './relations.js';
 import { release as releaseRow } from '../dispatch/Release.js';
 import type { Hosting } from './Hosting.js';
 import { peerOver } from './peerOver.js';
@@ -448,6 +448,7 @@ function readings(
           + `Call its operations through the façade instead.`,
         );
       }
+
       return route.schema;
     }
     throw new Error(notLoaded(entity));
@@ -489,6 +490,7 @@ function readings(
     const owner = fronds.owner(entity);
     if (!owner) {
       sayNoSurfaceAcross(entity, surface);
+
       return own;
     }
 
@@ -498,6 +500,7 @@ function readings(
     if (own) return own;
 
     const fallback = facadeAt(facadeKeyOf(entity), false);
+
     return fallback
       ? facadeOperations(
           localDispatcher,
@@ -515,6 +518,7 @@ function readings(
     const own = effectiveByKey.get(facadeKeyOf(entity, surface));
     const declared = fronds.owner(entity)?.surfaces?.[surface];
     if (!declared) return own;
+
     return declared.some((name) => name.toLowerCase() === entity.toLowerCase())
       ? (own ?? effectiveByKey.get(facadeKeyOf(entity)))
       : undefined;
@@ -699,6 +703,7 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
     for (const frond of fronds) await installFrond(frond, assembly);
 
     warnAboutRelations(relations, hosting, log);
+    refused.push(...unpaired(fronds.flatMap((frond) => frond.entities), hosting));
 
     // 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.
@@ -735,6 +740,7 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
     container.setFallback?.((name) => {
       if (!remoteRouter) return undefined;
       if (!name.endsWith('Handler') || name.includes(':')) return undefined;
+
       // Façade-shaped stand-in; routing happens lazily at the first call. Through
       // `lowerFirst` because a DEPENDENCY names the type as written — `ProductHandler`,
       // PascalCase — while a card declares `product`, so the raw strip asked the router for
@@ -752,6 +758,7 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
         if (known) return known;
         const facade = createRemoteFacade(entity, remoteRouter, getMiddlewares);
         remoteFacades.set(entity, facade);
+
         return facade;
       }));
     }
@@ -769,7 +776,7 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
       // Where a call goes, as DECLARED. Kept because a reader needs it beside what the
       // runtime OBSERVED — `rpc.topology` calls a frond remote because it answered, never
       // because a key said so, and the two disagree exactly when something is misconfigured.
-      remotes: Object.freeze({ ...(options.remotes ?? {}) }),
+      remotes: Object.freeze({ ...options.remotes }),
       dispatch: (call) => dispatcher.dispatch(call),
       local: localDispatcher,
       resolve,

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';
@@ -37,6 +38,7 @@ import { RouteAddress } from '../wire/RouteAddress.js';
 import { servedSurfaces } from '../descriptor/surface.js';
 import { OperationRoute } from '../dispatch/OperationRoute.js';
 import { facadeOperations } from '../entry/facade.js';
+import { decoded } from '../dispatch/decoded.js';
 
 /**
  * What the app is made of while it is still being made. `createApp` builds these, hands
@@ -306,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 });
@@ -449,6 +451,9 @@ function buildFacadeInto(
     handler.address,
     routeRegistry.operationNames(handler.address, handler.surface),
     handler.surface,
+    // The output SCHEMA, per op: `Crud(Post, { list: PostCard })` names a different one for
+    // one operation, so the answer is read back through the view that op actually serves.
+    (operation, answer) => decoded(facade.effectiveOperations.get(operation)?.output, answer),
   ));
 }
 
@@ -471,6 +476,7 @@ export async function installFrond(frond: FrondDescriptor, assembly: Assembly):
       emissions.note(contractsOf(operations), key);
 
     }
+
     return;
   }
   // A child hangs off its parent, so everything the parent registered answers here too and
@@ -495,6 +501,7 @@ 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.
   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);

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

@@ -5,6 +5,7 @@ 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 { 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 });
       }
     }
@@ -58,7 +59,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;
@@ -122,6 +123,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

package/src/boot/remote.ts

@@ -15,6 +15,7 @@ import { ErrorCode } from '../wire/ErrorCode.js';
 import { FougereError } from '../wire/FougereError.js';
 import { Card, type SchemaView, type SchemaDescriptor } from '@fougere/schema';
 import { dynamicOperations } from '../entry/facade.js';
+import { decoded } from '../dispatch/decoded.js';
 
 interface Route {
   frond: string;
@@ -53,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 };
@@ -103,13 +105,19 @@ export function createRemoteFacade(
   middlewaresFor: (address: string) => AppMiddleware[],
 ): Facade {
   const opFn = (op: string) => async (invocation: InvocationContext = Invocation.empty) => {
-    const { frond, transport } = await router.route(entity);
+    const { frond, transport, schema } = await router.route(entity);
     const call: FrondCall = { frond, entity, op };
     const ctx: OperationContext = {
       entity, frond, operation: op, args: [], state: invocation.state, invocation,
     };
-    return runMiddlewares(middlewaresFor(entity), ctx, () =>
+    const answer = await runMiddlewares(middlewaresFor(entity), ctx, () =>
       transport(call, ctx.invocation ?? invocation));
+
+    // 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);
   };
 
   return dynamicOperations(opFn) as Facade;

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

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