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

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';
@@ -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 });
@@ -475,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
@@ -499,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

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

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

package/src/builtin/config.ts

@@ -9,5 +9,6 @@ export class Config {
 
 function envOfProcess(): Record<string, string | undefined> {
   const proc = (globalThis as { process?: { env?: Record<string, string | undefined> } }).process;
+
   return proc?.env ?? {};
 }

package/src/contract.ts

@@ -80,5 +80,6 @@ export function callValueOf(
     typeof opOrInput === 'string'
       ? [{ entity: lowerFirst((target as { name: string }).name), op: opOrInput }, input]
       : [target as FrondCall, opOrInput];
+
   return { call, invocation: Invocation.from(given) };
 }

package/src/crypto/encoding.ts

@@ -13,6 +13,7 @@ export function b64url(input: Uint8Array | string): string {
   // One character at a time: `String.fromCharCode(...bytes)` overflows the argument
   // limit on a key, and a signature is small enough that the loop costs nothing.
   for (const byte of bytes) binary += String.fromCharCode(byte);
+
   return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
 }
 
@@ -20,6 +21,7 @@ export function unb64url(input: string): Uint8Array {
   const binary = atob(input.replace(/-/g, '+').replace(/_/g, '/'));
   const bytes = new Uint8Array(binary.length);
   for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
+
   return bytes;
 }
 
@@ -28,6 +30,7 @@ export const unb64 = (input: string): Uint8Array => {
   const binary = atob(input);
   const bytes = new Uint8Array(binary.length);
   for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
+
   return bytes;
 };
 
@@ -35,5 +38,6 @@ export const unb64 = (input: string): Uint8Array => {
 export function derOf(pem: string): Uint8Array {
   const body = pem.replace(/-----(BEGIN|END)[^-]+-----/g, '').replace(/\s+/g, '');
   if (body.length === 0) throw new Error('Not a PEM: no base64 body between the armour');
+
   return unb64(body);
 }

package/src/crypto/node.ts

@@ -13,6 +13,7 @@ export const crypto: CryptoPort = {
   async signerOf(privateKeyPem): Promise<Signer> {
     // Parsed here and captured, so a call signs against a KeyObject and never a string.
     const key = createPrivateKey(privateKeyPem);
+
     return { async sign(data) { return new Uint8Array(sign(null, data, key)); } };
   },
 
@@ -20,6 +21,7 @@ export const crypto: CryptoPort = {
     const parsed = typeof key === 'string'
       ? createPublicKey(key)
       : createPublicKey({ key: key as never, format: 'jwk' });
+
     return { async verify(data, signature) { return verify(null, data, parsed, signature); } };
   },
 };

package/src/crypto/webcrypto.ts

@@ -33,6 +33,7 @@ export const crypto: CryptoPort = {
     // Imported once, at boot. Doing it per call would put an async key parse inside
     // every outgoing request — the reason the port hands back a signer at all.
     const key = await subtle().importKey('pkcs8', derOf(privateKeyPem), ED25519, false, ['sign']);
+
     return { async sign(data) { return new Uint8Array(await subtle().sign(ED25519, key, data)); } };
   },
 
@@ -40,6 +41,7 @@ export const crypto: CryptoPort = {
     const imported = typeof key === 'string'
       ? await subtle().importKey('spki', derOf(key), ED25519, false, ['verify'])
       : await subtle().importKey('jwk', key, ED25519, false, ['verify']);
+
     return { verify: (data, signature) => subtle().verify(ED25519, imported, signature, data) };
   },
 };

package/src/descriptor/Fronds.ts

@@ -12,6 +12,7 @@ export class Fronds extends Array<FrondDescriptor> {
   static hosting(fronds: readonly FrondDescriptor[]): Fronds {
     const all = new Fronds();
     all.push(...fronds);
+
     return all;
   }
 
@@ -26,6 +27,7 @@ export class Fronds extends Array<FrondDescriptor> {
       const found = frond.entities.find((e) => e.name === name);
       if (found) return found;
     }
+
     return undefined;
   }
 

package/src/dispatch/ArrayResult.ts

@@ -6,5 +6,6 @@ export function preserveArrayProperties<T extends unknown[]>(source: unknown[],
         (source as unknown as Record<string, unknown>)[key];
     }
   }
+
   return target;
 }

package/src/dispatch/Dispatcher.ts

@@ -71,6 +71,7 @@ export class Dispatcher implements DispatchPort {
       this.lifecycle.publish(DispatchEvent.resolved(call, route.kind));
       const result = await route.execute(call);
       this.lifecycle.publish(DispatchEvent.completed(call, route.kind));
+
       return result;
     } catch (error) {
       this.lifecycle.publish(DispatchEvent.failed(call, error, route?.kind));

package/src/dispatch/HandlerFacade.ts

@@ -116,15 +116,23 @@ export class HandlerFacade {
 
     const args = contract.binding ? await this.arguments.resolve(contract.binding, validated) : [];
     const { instance, method } = this.resolveImplementation(op);
-    const view = this.viewOf(op);
-    const output = view.project(await instance[method](...args));
+    const answered = await instance[method](...args);
 
+    const view = this.viewOf(op);
     const { presenter } = this.facade;
+    const computed = view.closed || !presenter
+      ? answered
+      : await this.present(op, presenter, answered, validated);
 
-    return view.closed || !presenter ? output : this.present(op, presenter, output, validated);
+    return view.project(computed);
   }
 
-  /** The computed fields a presenter adds, over the page the façade just projected. */
+  /**
+   * The computed fields a presenter adds, over the rows the handler answered and BEFORE the
+   * view projects them. A presenter runs on the server, so what it reads is the row the
+   * storage holds: a `writeOnly` field is gone by the time the client sees it, and deriving
+   * from one is the whole reason to declare it.
+   */
   private present(
     op: string,
     presenter: PresenterEntry,
@@ -180,12 +188,14 @@ export class HandlerFacade {
       operation?.outputClosed ?? false,
     );
     this.cachedViews.set(op, resolved);
+
     return resolved;
   }
 
   /** The handler itself, resolved on first call — never at boot. */
   private resolveHandler(): any {
     if (!this.instance) this.instance = this.scope.resolve(this.handlerKey);
+
     return this.instance;
   }
 
@@ -208,6 +218,7 @@ export class HandlerFacade {
         + `${operation.implementation.method}, but boot found ${matches.length} matching handlers.`,
       );
     }
+
     return matches[0]!;
   }
 
@@ -225,6 +236,7 @@ export class HandlerFacade {
       instance = this.scope.resolve(key);
       this.implementationInstances.set(key, instance);
     }
+
     return { instance, method: operation.implementation.method };
   }
 }

package/src/dispatch/InFlight.ts

@@ -23,6 +23,7 @@ export class InFlight {
 
     this.running++;
     let released = false;
+
     return () => {
       if (released) return;
       released = true;
@@ -41,6 +42,7 @@ export class InFlight {
 
   whenIdle(): Promise<void> {
     if (this.running === 0) return Promise.resolve();
+
     return new Promise((resolve) => this.idle.push(resolve));
   }
 }