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

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;
   }
 
@@ -39,6 +41,16 @@ export class Fronds extends Array<FrondDescriptor> {
     return this.flatMap((frond) => frond.entities.map((e) => e.name)).sort();
   }
 
+  /**
+   * Whether a named surface serves an entity, as its owning frond declared it — `undefined` when
+   * that frond declares no such surface, and a facade registered there answers as it is.
+   */
+  admits(surface: string, entity: string): boolean | undefined {
+    const declared = this.owner(entity)?.surfaces?.[surface];
+
+    return declared?.some((name) => name.toLowerCase() === entity.toLowerCase());
+  }
+
   /** The names a call may address, sorted — what a NOT_FOUND must print. */
   servedNames(surface?: string): string[] {
     return this.flatMap((frond) => frond.handlers

package/src/descriptor/index.ts

@@ -23,6 +23,7 @@ export { type TypeRef } from '../wire/TypeRef.js';
 export { computeBindingPlan, type BindingPlan } from '../wire/binding.js';
 export type { Signature } from '../wire/Signature.js';
 export { awaitKeyOf, emitKeyOf } from '../wire/Emit.js';
+export { addressOf } from '../wire/Facade.js';
 export { storageKeyOf } from '../storage/Storage.js';
 export { getPresenterFields } from '../prefab/presenter.js';
 export { targetOf, viewsOf, outputOf } from '../prefab/prefab.js';

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;
@@ -35,12 +36,27 @@ export class InFlight {
     };
   }
 
-  close(): void {
+  /** Close the door, and answer once the calls already running are done — or refuse at the deadline, naming what is left. */
+  async drain(timeoutMs?: number): Promise<void> {
     this.accepting = false;
+    if (timeoutMs === undefined) return this.whenIdle();
+
+    let timer: ReturnType<typeof setTimeout>;
+
+    await Promise.race([
+      this.whenIdle().then(() => clearTimeout(timer)),
+      new Promise<never>((_, reject) => {
+        timer = setTimeout(
+          () => reject(new Error(`[drain] ${this.running} call(s) still running after ${timeoutMs}ms`)),
+          timeoutMs,
+        );
+      }),
+    ]);
   }
 
-  whenIdle(): Promise<void> {
+  private whenIdle(): Promise<void> {
     if (this.running === 0) return Promise.resolve();
+
     return new Promise((resolve) => this.idle.push(resolve));
   }
 }

package/src/dispatch/LocalRoutePolicy.ts

@@ -22,6 +22,7 @@ export class LocalRoutePolicy implements RoutePolicy {
     const hosted = this.hostedNames(call.address.surface);
     const entity = call.address.entity;
     const surface = call.address.surface;
+
     return new FougereError({
       code: ErrorCode.NOT_FOUND,
       message: (surface

package/src/dispatch/RouteRegistry.ts

@@ -35,6 +35,7 @@ export class RouteRegistry {
       entity: address.entity,
       operation: address.operation,
     }).key());
+
     return shared?.kind === 'system' ? shared : undefined;
   }
 
@@ -48,6 +49,7 @@ export class RouteRegistry {
 
     const resolution = this.resolveUnknown(address).finally(() => this.pending.delete(key));
     this.pending.set(key, resolution);
+
     return resolution;
   }
 
@@ -56,8 +58,10 @@ export class RouteRegistry {
       const route = await resolver(address);
       if (!route) continue;
       this.register(route);
+
       return route;
     }
+
     return undefined;
   }
 

package/src/dispatch/StorageGuard.ts

@@ -1,4 +1,4 @@
-import { FieldSet, FieldValueValidator, InputRefusal, type Fields, type Verdict } from '@fougere/schema';
+import { FieldSet, FieldValueValidator, InputRefusal, Role, type Fields, type Verdict } from '@fougere/schema';
 import { COMPARISONS, comparisonOf, unknownIn } from '../storage/Comparison.js';
 import { assertListOptions } from '../storage/Storage.js';
 import { ErrorCode } from '../wire/ErrorCode.js';
@@ -69,12 +69,14 @@ export class StorageGuard {
     guarded.create = async function (...args) {
       args[0] = validation.validated(args[0], 'create');
       await validation.targetsOf([args[0]], 'create');
+
       return writer.create.apply(this, args);
     };
 
     guarded.update = async function (...args) {
       args[1] = validation.validated(args[1], 'update');
       await validation.targetsOf([args[1]], 'update');
+
       return writer.update.apply(this, args);
     };
 
@@ -83,6 +85,7 @@ export class StorageGuard {
       guarded.upsert = async function (...args) {
         args[0] = validation.validated(args[0], 'upsert');
         await validation.targetsOf([args[0]], 'upsert');
+
         return upsert.apply(this, args);
       };
     }
@@ -94,6 +97,7 @@ export class StorageGuard {
       guarded.upsertAll = async function (...args) {
         args[0] = args[0].map((row, index) => validation.validated(row, 'upsertAll', index));
         await validation.targetsOf(args[0], 'upsertAll');
+
         return upsertAll.apply(this, args);
       };
     }
@@ -122,6 +126,7 @@ export class StorageGuard {
   private rowAt(row: unknown, index: number): string {
     const primary = FieldSet.of(this.fields).primary;
     const key = primary === undefined ? undefined : (row as Record<string, unknown>)[primary];
+
     return key === undefined ? `row ${index} of this page` : `row ${primary} ${JSON.stringify(key)}`;
   }
 
@@ -213,6 +218,8 @@ export class StorageGuard {
   private written(key: string, item: unknown): Verdict {
     const field = this.fields[key];
     if (!field) return { message: InputRefusal.unknownField };
+    // Declared, and still nothing to write: the other side of the relation carries the key.
+    if (Role.of(field).isCollection()) return { message: InputRefusal.readOnly };
     if (item === undefined) return { value: item };
 
     return FieldValueValidator.of(field).parse(item);
@@ -220,6 +227,7 @@ export class StorageGuard {
 
   private value(field: Fields[string], asked: unknown): Verdict {
     if (asked === null || asked === undefined) return { value: asked };
+
     return FieldValueValidator.of(field).parse(asked);
   }
 

package/src/identity-keys.ts

@@ -5,6 +5,7 @@ import { b64url } from './crypto/encoding.js';
 /** A fresh Ed25519 pair, PEM both ways. The root's and a frond's are the same kind. */
 export function generateKeyPair(): { privateKey: string; publicKey: string } {
   const { privateKey, publicKey } = generateKeyPairSync('ed25519');
+
   return {
     privateKey: privateKey.export({ type: 'pkcs8', format: 'pem' }).toString(),
     publicKey: publicKey.export({ type: 'spki', format: 'pem' }).toString(),
@@ -26,5 +27,6 @@ export function issueGrant(
   const header = b64url(JSON.stringify({ alg: 'EdDSA', typ: 'fougere-grant' }));
   const payload = b64url(JSON.stringify({ sub: name, jwk, iat: now, exp: now + ttlDays * 86_400_000 }));
   const signingInput = `${header}.${payload}`;
+
   return `${signingInput}.${b64url(new Uint8Array(sign(null, Buffer.from(signingInput), createPrivateKey(rootPrivateKey))))}`;
 }

package/src/index.ts

@@ -91,7 +91,7 @@ export type { FougereOperations } from './wire/FougereOperations.js';
 export type { HandlerOf } from './wire/HandlerOf.js';
 export type { Refused } from './wire/Refused.js';
 export type { Rows } from './wire/Rows.js';
-export type { Facade } from './wire/Facade.js';
+export { addressOf, type Facade } from './wire/Facade.js';
 export type {
   FrondCall,
   Transport,
@@ -150,9 +150,7 @@ export type { PresenterEntry } from './descriptor/PresenterEntry.js';
 export type { PresenterFieldMeta } from './descriptor/PresenterFieldMeta.js';
 export type { ProviderEntry } from './descriptor/ProviderEntry.js';
 export type { SeedEntry } from './descriptor/SeedEntry.js';
-export type { AuthConfig } from './boot/AuthConfig.js';
-export type { AuthContext } from './boot/AuthContext.js';
-export type { AuthRuntime } from './boot/AuthRuntime.js';
+export { AUTH, type AuthRuntime } from './boot/AuthRuntime.js';
 export { Fronds } from './descriptor/Fronds.js';
 export { verify, type Misplaced } from './verify.js';
 // Same question as verify(), answered from the source text instead of the model.

package/src/loader.ts

@@ -11,6 +11,7 @@ const defaultLoader: ModuleLoader = async (filePath, options) => {
   // On the URL, never on the path: `pathToFileURL` percent-encodes a `?` into the
   // filename, and the import then looks for a file whose name ends in `%3Fv=…`.
   const url = pathToFileURL(filePath).href;
+
   return await import(options?.fresh ? `${url}?v=${Date.now()}` : url);
 };
 

package/src/node.ts

@@ -1,6 +1,6 @@
 /** What Fougere does with a filesystem, minus the scan — that is `@fougere/compiler`. */
 export { setModuleLoader, getModuleLoader } from './loader.js';
-export { loadConfig, loadCascadedConfig, remotesOf } from './FougereConfig.js';
+export { configFileIn, loadConfig, loadCascadedConfig, remotesOf } from './FougereConfig.js';
 export { statedModules } from './StatedModules.js';
 export { defineFrond, loadFrondConfig } from './FrondConfig.js';
 

package/src/prefab/CrudConstructor.ts

@@ -1,10 +1,8 @@
 import { lowerFirst, type EntityConstructor, type SchemaView } from '@fougere/schema';
 import type { ListOptions } from '../storage/ListOptions.js';
-import type { ListResult } from '../storage/ListResult.js';
 import type { Storage } from '../storage/Storage.js';
 import type { OperationContract } from '../wire/OperationContract.js';
 import { targetOf } from './prefab.js';
-import type { CrudOpName } from './CrudOpName.js';
 import type { CrudViews } from './CrudViews.js';
 import { pageOf, type Page } from '../wire/Page.js';
 import type { CrudOps } from './CrudOps.js';
@@ -52,6 +50,7 @@ const returns = (raw: string, name: string, extra?: { array?: boolean; nullable?
 function crudOps(entity: SchemaView & { partial?: () => SchemaView }): Record<string, OperationContract> {
   const name = (entity as { name?: string }).name ?? 'Entity';
   const input = inputParam(name);
+
   return {
     list: {
       output: entity, cardinality: 'page',
@@ -87,15 +86,6 @@ function asCrudConstructor<T, V>(impl: object): CrudConstructor<T, V> {
   return impl as CrudConstructor<T, V>;
 }
 
-/** The view an op emits, fabricated. */
-type OutOf<V, K extends CrudOpName, T> =
-  // Bracketed on purpose: a naked `V extends …` DISTRIBUTES, and the no-view default
-  // is the empty map, whose `keyof` is `never` — distribution would then collapse
-  // every op's output to `never` instead of falling through to the entity.
-  [V] extends [EntityConstructor] ? InstanceType<V & EntityConstructor>
-  : K extends keyof V ? (V[K] extends EntityConstructor ? InstanceType<V[K]> : T)
-  : T;
-
 /** The prefab handler class — its ops, plus the statics the bootstrap and adapters read. */
 export interface CrudConstructor<T, V = {}> {
   // `Storage<T>`, not the bare `Storage`: a handler that injects a second storage has to

package/src/prefab/collector.ts

@@ -10,6 +10,7 @@ export function Collector<T extends abstract new (...args: any[]) => any>(target
   class CollectorBase {
     static readonly __entity = target;
   }
+
   return CollectorBase;
 }
 

package/src/prefab/presenter.ts

@@ -18,6 +18,7 @@ export function Presenter<E extends EntityConstructor>(entity: E, views?: Presen
     static readonly __entity = entity;
     static readonly __views = views;
   }
+
   return PresenterBase;
 }
 

package/src/storage/Comparison.ts

@@ -1,5 +1,4 @@
 import { type Field, Shapes } from '@fougere/schema';
-import type { ComparisonName } from './ComparisonName.js';
 
 /**
  * The comparisons a criterion may name.
@@ -21,7 +20,11 @@ export interface Comparison {
   isNull?: boolean;
 }
 
-export const COMPARISONS = ['gte', 'lte', 'gt', 'lt', 'ne', 'between', 'contains', 'notIn', 'isNull'] as const;
+export type ComparisonName = keyof Comparison;
+
+export const COMPARISONS = Object.keys({
+  gte: true, lte: true, gt: true, lt: true, ne: true, between: true, contains: true, notIn: true, isNull: true,
+} satisfies Record<ComparisonName, true>);
 
 /**
  * Is this criterion a comparison, or a value that happens to be an object?
@@ -42,11 +45,11 @@ export function comparisonOf(field: Field | undefined, asked: unknown): Comparis
 /** The comparisons a criterion names, in the order the caller wrote them. */
 export function comparisonsIn(comparison: Comparison): [ComparisonName, unknown][] {
   return Object.entries(comparison).filter(
-    (entry): entry is [ComparisonName, unknown] => (COMPARISONS as readonly string[]).includes(entry[0]),
+    (entry): entry is [ComparisonName, unknown] => COMPARISONS.includes(entry[0]),
   );
 }
 
 /** What a comparison names that this vocabulary does not — a typo, said as one. */
 export function unknownIn(comparison: Comparison): string[] {
-  return Object.keys(comparison).filter((name) => !(COMPARISONS as readonly string[]).includes(name));
+  return Object.keys(comparison).filter((name) => !COMPARISONS.includes(name));
 }

package/src/storage/Storage.ts

@@ -159,6 +159,7 @@ const HELD = 'Storage';
  */
 export function togetherKeyOf(entities: readonly string[], providers: readonly string[] = []): string {
   const named = entities.map(upperFirst).join(SEPARATOR);
+
   return `${named}${providers.length ? KINDS + providers.map(upperFirst).join(SEPARATOR) : ''}${FRAME}`;
 }
 
@@ -174,5 +175,6 @@ export function membersOfTogetherKey(key: string): { entities: string[]; provide
   if (key.length <= FRAME.length || !key.endsWith(FRAME)) return undefined;
   const [entities = '', providers = ''] = key.slice(0, -FRAME.length).split(KINDS);
   const split = (list: string) => list.split(SEPARATOR).filter(Boolean);
+
   return { entities: split(entities), providers: split(providers) };
 }

package/src/storage/Store.ts

@@ -21,7 +21,7 @@ export function storageOver(open: (entity: SchemaView, name: string) => Store):
   return (entity: SchemaView, name: string): Storage => {
     const fields = entity.getFields();
     const store = open(entity, name);
-    const pk = Object.entries(fields).find(([, field]) => Role.of(field).isPrimary)?.[0] ?? 'id';
+    const pk = Object.entries(fields).find(([, field]) => Role.of(field).isPrimary())?.[0] ?? 'id';
     // `Storage.findById(id: string)` — but a key can hold a number, and a Map keyed on
     // `1` does not answer `'1'`. SQL never had the question; here the divergence was
     // silent and only on this storage.
@@ -57,6 +57,7 @@ export function storageOver(open: (entity: SchemaView, name: string) => Store):
         const previous = await store.get(keyOf(id));
         const values = previous ? { ...previous, ...applyUpdate(fields, input) } : created;
         await store.set(keyOf(id), values);
+
         return pick(values);
       };
 
@@ -71,10 +72,12 @@ export function storageOver(open: (entity: SchemaView, name: string) => Store):
         },
         async findById(id: string) {
           const values = await store.get(keyOf(id));
+
           return values && pick(values);
         },
         async findBy(criteria: Record<string, unknown>) {
           const values = (await store.all()).find((held) => matches(held, criteria));
+
           return values && pick(values);
         },
         async findAllBy(criteria: Record<string, unknown>) {
@@ -87,6 +90,7 @@ export function storageOver(open: (entity: SchemaView, name: string) => Store):
             const values = await store.get(keyOf(id));
             if (values) found.set(String(id), pick(values));
           }
+
           return found;
         },
         // The dual, same contract as SQL: grouped by the value read off the instance.
@@ -100,11 +104,13 @@ export function storageOver(open: (entity: SchemaView, name: string) => Store):
             const bucket = grouped.get(key);
             if (bucket) bucket.push(pick(values)); else grouped.set(key, [pick(values)]);
           }
+
           return grouped;
         },
         upsert,
         async upsertAll(inputs: readonly Partial<Record<string, unknown>>[]) {
           for (const input of inputs) await upsert(input);
+
           return inputs.length;
         },
         async create(input: Partial<Record<string, unknown>>) {
@@ -125,6 +131,7 @@ export function storageOver(open: (entity: SchemaView, name: string) => Store):
             throw new Error(`${name}.create: '${pk}' ${JSON.stringify(id)} already exists.`);
           }
           await store.set(keyOf(id), values);
+
           return pick(values);
         },
         async update(id: string, input: Partial<Record<string, unknown>>) {
@@ -132,6 +139,7 @@ export function storageOver(open: (entity: SchemaView, name: string) => Store):
           if (!existing) throw new Error(`Not found: ${id}`);
           const updated = { ...existing, ...applyUpdate(fields, input), [pk]: existing[pk] };
           await store.set(keyOf(id), updated);
+
           return pick(updated);
         },
         async delete(id: string) { return await store.delete(keyOf(id)); },

package/src/verify.ts

@@ -42,6 +42,7 @@ function registrationsOf(frond: FrondDescriptor): Map<string, Registration> {
     put(storageKeyOf(e.name), 'storage');
     put(repositoryKeyOf(e.name), 'repository');
   }
+
   return out;
 }
 
@@ -143,6 +144,7 @@ export function verify(app: { fronds: readonly FrondDescriptor[] }): Misplaced[]
       }
     }
   }
+
   return violations;
 }
 

package/src/wire/AppMiddleware.ts

@@ -27,7 +27,9 @@ export function runMiddlewares(
     if (index < middlewares.length) {
       return middlewares[index++](ctx, next);
     }
+
     return handler();
   };
+
   return next();
 }

package/src/wire/Emit.ts

@@ -35,7 +35,7 @@ export function factOfEmitKey(key: string): string | undefined {
 }
 
 /** The fact behind an awaited emission's key — the dual, read the same way. */
-export function factOfAwaitKey(key: string): string | undefined {
+function factOfAwaitKey(key: string): string | undefined {
   return behind(key, AWAIT_SUFFIX);
 }
 

package/src/wire/Facade.ts

@@ -1,14 +1,6 @@
-import type { InvocationContext } from './InvocationContext.js';
-import type { FougereOperations } from './FougereOperations.js';
-
-type Served = keyof FougereOperations & string;
+import { lowerFirst } from '@fougere/schema';
 
-/**
- * Both halves below take the union through a type PARAMETER, which is what makes the
- * conditional distribute: `Served` is an alias, and an alias is matched whole — `'a.x' | 'b.y'`
- * does not extend `` `${string}.${string}` `` as one thing, so the naive form answers `never`.
- */
-type AddressIn<Key> = Key extends `${infer Address}.${string}` ? Address : never;
+import type { InvocationContext } from './InvocationContext.js';
 
 /**
  * The facade built in front of a handler — the framework's second port, after `Storage`.
@@ -34,6 +26,21 @@ export function facadeKeyOf(entityName: string, surface?: string): string {
   return surface ? `${surface}:${entityName}Handler` : `${entityName}Handler`;
 }
 
+/**
+ * The address a handler answers at, read off its class name or its facade key — the dual of
+ * `facadeKeyOf`. `PostHandler` → `post`, `postHandler` → `post`.
+ */
+export function addressOf(name: string): string {
+  return lowerFirst(name.endsWith(HANDLER) ? name.slice(0, -HANDLER.length) : name);
+}
+
+/** A default facade's key — `postHandler`, never `admin:postHandler` nor `PostStorage`. */
+export function isFacadeKey(key: string): boolean {
+  return key.endsWith(HANDLER) && !key.includes(':');
+}
+
+const HANDLER = 'Handler';
+
 /** Where the contracts behind a façade live — the dual of `facadeKeyOf`. */
 export function contractsKeyOf(entityName: string, surface?: string): string {
   return `${facadeKeyOf(entityName, surface)}:contracts`;

package/src/wire/FougereError.ts

@@ -41,6 +41,7 @@ export class FougereError<Code extends ErrorCode = ErrorCode> extends Error {
   static fromJSON(json: unknown): FougereError {
     const raw = (typeof json === 'object' && json !== null ? json : {}) as Record<string, unknown>;
     const known = Object.values(ErrorCode).includes(raw.code as ErrorCode);
+
     return new FougereError({
       code: known ? (raw.code as ErrorCode) : ErrorCode.INTERNAL_ERROR,
       message: typeof raw.message === 'string' ? raw.message : 'Unknown error',
@@ -65,5 +66,6 @@ export function validationErrorsOf(error: unknown): ValidationError[] | undefine
       && Array.isArray((entry as ValidationError).path)
       && typeof (entry as ValidationError).message === 'string',
   );
+
   return refusals.length === details.length ? refusals : undefined;
 }