@fougere/core 0.6.0-alpha.0 → 0.8.0-alpha.0

package/src/contract.ts

@@ -1,61 +1,43 @@
 /**
- * Contract surface — what a sender needs to speak to a receiver, and
- * nothing that assumes a runtime: the error vocabulary, the invocation
- * shape, the call value, the naming convention.
- *
- * Browser-safe by design: no node builtin may enter this module's import
- * graph. Published as the `@fougere/core/contract` subpath so client
- * bundles never touch the full index (scanner, config loader). `@fougere/schema`
- * is allowed in — measured, it imports no node builtin either.
+ * Contract surface — what a sender needs to speak to a receiver, and nothing that assumes a
+ * runtime: the error vocabulary, the invocation shape, the call value, the naming convention.
  */
 import { lowerFirst } from '@fougere/schema';
-import { canonicalInvocation, type InvocationContext } from './contract/Invocation.js';
+import { canonicalInvocation, type InvocationContext } from './wire/Invocation.js';
 import type { FrondCall } from './wire/call.js';
 
 export { FougereError, ErrorCode, validationErrorsOf } from './wire/errors.js';
+// What a read may ask about one field. Here rather than on the main entry because an
+// adapter reads it to compile a query, and an adapter carries no boot.
+export { comparisonOf, comparisonsIn, unknownIn, COMPARISONS } from './criterion.js';
+export type { Comparison, ComparisonName } from './criterion.js';
 // A receiver turns a refusal into what may cross a process boundary, and it is not
 // core's boot — reaching it through the main entry dragged the scanner into a bundle.
 export { toPublicError } from './wire/http-error.js';
 export type { FougereErrorOptions } from './wire/errors.js';
-export { canonicalInvocation, EMPTY_INVOCATION } from './contract/Invocation.js';
-export type { InvocationContext } from './contract/Invocation.js';
-export { Invocation } from './contract/Invocation.js';
-export type { InvocationInput } from './contract/Invocation.js';
-export { Call } from './contract/Call.js';
-export { RouteAddress } from './contract/RouteAddress.js';
-export type { RouteAddressInput } from './contract/RouteAddress.js';
+export { canonicalInvocation, EMPTY_INVOCATION } from './wire/Invocation.js';
+export type { InvocationContext } from './wire/Invocation.js';
+export { Invocation } from './wire/Invocation.js';
+export type { PartialInvocation } from './wire/Invocation.js';
+export { Call } from './wire/call.js';
+export { RouteAddress } from './wire/RouteAddress.js';
+export type { RouteAddressInput } from './wire/RouteAddress.js';
 export type { FrondCall, Transport, SignedCall } from './wire/call.js';
 export { MAX_BODY_BYTES } from './wire/call.js';
 // The reserved entity, VALUE and not type: a consumer that wants to leave it alone — a
 // call log ignoring its own reader — has to be able to name it.
 export { RPC_ENTITY } from './wire/call.js';
-export type { CallPage, CallRecord } from './contract/CallLog.js';
+export type { CallPage, CallRecord } from './wire/CallLog.js';
 // The comparison of two cards, which a consumer runs about a producer — browser-safe on
 // purpose: a panel showing the drift holds only the two cards, never the app.
 export { driftOf, agrees, explain } from './wire/drift.js';
 export type { CardDrift } from './wire/drift.js';
 
-/**
- * What `rpc.discover` answers. It belongs here and not to the runtime: the
- * reserved op travels on the same wire as every other call, so a consumer that
- * only sends — a browser bundle, a frond written elsewhere — needs its shape and
- * nothing else. Type-only, so `call.js` never enters the runtime graph.
- *
- * Stated once, on purpose: two private copies of this interface have already gone
- * stale (the CLI's, then the Rust demo's) the day an op stopped being a bare name.
- */
+/** What `rpc.discover` answers. */
 export type { IdentityCard, CardOp, TopologyReport, FrondPlacement, Edge } from './wire/call.js';
 export { assertIdentityCard } from './wire/call.js';
 
-/**
- * The key a class name is filed under — 'Post' → 'post'. Re-exported rather than
- * respelled: a card writes it and a foreign key derives from it, so the convention
- * belongs to the schema, and a second copy here is a second opinion. It travels
- * through this subpath because a consumer of the wire (a browser bundle) may hold no
- * schema dependency of its own — that audience only. Inside the package it is read from
- * `@fougere/schema` directly: routing four modules through here bought nothing and put
- * this file inside a cycle.
- */
+/** The key a class name is filed under — 'Post' → 'post'. */
 export { lowerFirst } from '@fougere/schema';
 
 /** A call, fully fabricated: the designation and its completed invocation. */
@@ -65,10 +47,8 @@ export interface CallValue {
 }
 
 /**
- * Fabricate the call value — one designation, two spellings:
- * `callValueOf(Post, 'list', { query })` (class + verb) or
- * `callValueOf({ entity, op }, input)` (raw, for dynamic bridges).
- * Missing invocation fields complete to the empty invocation.
+ * Fabricate the call value — one designation, two spellings: `callValueOf(Post, 'list', { query
+ * })` (class + verb) or `callValueOf({ entity, op }, input)` (raw, for dynamic bridges).
  */
 export function callValueOf(
   target: { name: string } | FrondCall,

package/src/criterion.ts

@@ -0,0 +1,54 @@
+/** What a read may ask about one field, and how a storage tells the two forms apart. */
+import { type Field, Shapes } from '@fougere/schema';
+
+/**
+ * The comparisons a criterion may name.
+ *
+ * `eq` and `in` are not here: a bare value already means equality and an array already
+ * means membership, and giving them a second spelling would make one criterion sayable
+ * two ways. What is added is what those two could not say at all.
+ */
+export interface Comparison {
+  gte?: unknown;
+  lte?: unknown;
+  gt?: unknown;
+  lt?: unknown;
+  ne?: unknown;
+  /** Both bounds, inclusive — `between: [1500, 4000]`. */
+  between?: [unknown, unknown];
+  contains?: string;
+  notIn?: readonly unknown[];
+  isNull?: boolean;
+}
+
+export const COMPARISONS = ['gte', 'lte', 'gt', 'lt', 'ne', 'between', 'contains', 'notIn', 'isNull'] as const;
+
+export type ComparisonName = (typeof COMPARISONS)[number];
+
+/**
+ * Is this criterion a comparison, or a value that happens to be an object?
+ *
+ * Read off the FIELD, never off the value. `json()` admits any shape, so `{ gte: … }` is
+ * a legal thing to store — telling the two apart by looking at the criterion would make a
+ * stored object unfilterable the day its keys happened to spell an operator. The shape
+ * knows, and it is the only thing that does.
+ */
+export function comparisonOf(field: Field | undefined, asked: unknown): Comparison | undefined {
+  if (asked === null || typeof asked !== 'object' || Array.isArray(asked)) return undefined;
+  // `Shapes.of` answers with `null` already taken out — `optional(json())` is an object.
+  if (!field || Shapes.of(field.shape).base?.type === 'object') return undefined;
+
+  return asked as Comparison;
+}
+
+/** 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]),
+  );
+}
+
+/** 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));
+}

package/src/crypto/encoding.ts

@@ -1,11 +1,4 @@
-/**
- * What both realizations spell identically — bytes in, bytes out, no platform.
- *
- * `Buffer` did all of this and does not exist on a Worker; `atob`/`btoa` exist on both.
- * Nothing here is a policy decision, which is why it sits beside the port rather than
- * inside either half: two copies of a base64url would be two chances to disagree on the
- * padding, and the disagreement would show up as a bad signature.
- */
+/** What both realizations spell identically — bytes in, bytes out, no platform. */
 
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
@@ -45,13 +38,7 @@ export const unb64 = (input: string): Uint8Array => {
   return bytes;
 };
 
-/**
- * The DER a PEM wraps. WebCrypto imports DER and knows nothing about the armour.
- *
- * The label is not checked: a caller asking for a private key and handed a public one
- * fails at `importKey` with a message about the key, which is the truer error than one
- * about a header line.
- */
+/** The DER a PEM wraps. */
 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');

package/src/crypto/node.ts

@@ -1,10 +1,4 @@
-/**
- * Ed25519 through `node:crypto` — the default realization, and the fast one.
- *
- * `sign`/`verify` are synchronous here and stay synchronous: the promise is put around
- * the answer, never around the work. That is the whole reason this file exists rather
- * than everyone sharing the WebCrypto half.
- */
+/** Ed25519 through `node:crypto` — the default realization, and the fast one. */
 import { createHash, createPrivateKey, createPublicKey, sign, verify } from 'node:crypto';
 import type { CryptoPort, PublicJwk, Signer, Verifier } from './port.js';
 

package/src/crypto/port.ts

@@ -1,20 +1,4 @@
-/**
- * The two Ed25519 gestures a signed call needs, and the one hash that binds it.
- *
- * Node signs 59% faster than WebCrypto on the same curve (measured 2026-08-23: 14.30 µs
- * against 22.72 µs per signature, 34.42 against 41.81 to verify), so this is a PORT with
- * two realizations and not one implementation at the lowest common denominator. `#crypto`
- * resolves to `crypto/node.ts` everywhere except under the `workerd` condition — the
- * bundler picks at build time, and neither half ever appears in the other's output.
- *
- * The shape is async because WebCrypto is. On Node that costs one microtask, which the
- * same measurement puts inside the noise of the signature itself (14.30 sync against
- * 14.28 awaited) — awaiting is free, converting is not.
- *
- * A KEY IS PARSED ONCE. `crypto.subtle.importKey` is async and per-key, so an interface
- * shaped `sign(key, data)` would import on every call; `signerOf(pem)` hands back
- * something that holds the parsed key, and a boot builds it once.
- */
+/** The two Ed25519 gestures a signed call needs, and the one hash that binds it. */
 
 /** A parsed private key. */
 export interface Signer {
@@ -36,7 +20,7 @@ export interface PublicJwk {
 }
 
 export interface CryptoPort {
-  /** SHA-256. What binds a body to an envelope without carrying the body. */
+  /** SHA-256. What binds an input to an envelope without carrying the input. */
   sha256(data: Uint8Array): Promise<Uint8Array>;
   /** From a PKCS#8 PEM — what `fougere keys` writes. */
   signerOf(privateKeyPem: string): Promise<Signer>;

package/src/crypto/webcrypto.ts

@@ -1,15 +1,4 @@
-/**
- * Ed25519 through WebCrypto — what a runtime with no `node:` builtin has.
- *
- * Verified in real workerd with no compatibility flag (2026-08-23): sign, verify, a JWK
- * import, an SPKI import and SHA-256 all answer. `Ed25519` is the algorithm name; the
- * older `NODE-ED25519` spelling is not used, and a runtime that only knows that one will
- * refuse at `importKey` rather than silently signing with something else.
- *
- * The four gestures are declared here rather than pulled from `lib.dom`: this package
- * compiles with `lib: ["ESNext"]` and naming DOM would make every consumer carry a
- * browser's globals to read a server type. What the file needs IS the declaration.
- */
+/** Ed25519 through WebCrypto — what a runtime with no `node:` builtin has. */
 import { derOf } from './encoding.js';
 import type { CryptoPort, PublicJwk, Signer, Verifier } from './port.js';
 

package/src/declare.ts

@@ -1,20 +1,4 @@
-/**
- * A frond stated by its author, for an app that will not scan.
- *
- * The scan reads the type checker because a signature IS a declaration — and that reading
- * has to happen while the types still exist, which is build time. An app that wants
- * neither a build step nor `typescript` at runtime says the same thing here instead, and
- * `createApp` cannot tell the difference: it consumes a `ScanResult`, never a scanner.
- *
- * What it does NOT ask for is the point. Every name the scan derives from a class is
- * derived here the same way — `PostHandler` answers at `post`, `Post` is stored as `post`
- * — so a declaration states classes and nothing else. `filePath` is empty because there is
- * no file to point at, and a diagnostic that would have quoted one says so plainly.
- *
- * Measured on `demos/nuxt-blog`: 23 of its 29 operations need no word here at all, because
- * `Crud.__ops` declares them at runtime. Only the six the author wrote by hand cost
- * anything, and they cost `frond.config.ts` — where what is not derivable is stated.
- */
+/** A frond stated by its author, for an app that will not scan. */
 import { lowerFirst, type SchemaView } from '@fougere/schema';
 import type {
   CollectorEntry, EntityEntry, FrondDescriptor, HandlerEntry,
@@ -22,17 +6,12 @@ import type {
 } from './descriptor/frond.js';
 import { DEFAULT_CONVENTIONS } from './scan/conventions.js';
 import { getPresenterFields } from './prefab/presenter.js';
+import type { OperationContract } from './wire/operation.js';
 
 /** A class, as a declaration hands it over: the constructor itself. */
 type Ctor = new (...args: never[]) => unknown;
 
-/**
- * What a subject needs beyond its class, when its constructor names a frame or a port.
- *
- * `deps` is the one thing no runtime can recover: TypeScript erases the parameter types,
- * and `registerFrames` reads them to know which frames to build — asking for one IS
- * declaring it. A handler that takes only its own entity's storage needs nothing here.
- */
+/** What a subject needs beyond its class, when its constructor names a frame or a port. */
 export interface DeclaredSubject {
   ctor: Ctor;
   deps?: string[];
@@ -41,23 +20,31 @@ export interface DeclaredSubject {
 /** A handler, and the surface it answers on when it is not the default one. */
 export interface DeclaredHandler extends DeclaredSubject {
   /**
-   * The scan reads this from the directory (`handlers/public/`), so a statement has to
-   * say it: two handlers over one entity collide on their address otherwise, and the
-   * refusal names the same route twice.
+   * The scan reads this from the directory (`handlers/public/`), so a statement has to say it: two
+   * handlers over one entity collide on their address otherwise, and the refusal names the same
+   * route twice.
    */
   surface?: string;
+  /**
+   * What each method takes and answers — read from SOURCE by the scan, and unreachable
+   * from a class at runtime. A prefab declares its own (`Crud.__ops`) and needs nothing
+   * here; a method someone wrote does, or the route it should serve does not exist.
+   */
+  operations?: ReadonlyMap<string, OperationContract> | Record<string, OperationContract>;
 }
 
 /** A class on its own, or a class with what it asks for. */
-export type Declared = Ctor | DeclaredSubject;
+export type Declared = Ctor | (DeclaredSubject & {
+  /** The container key, when the class's own name cannot be trusted to survive a build. */
+  name?: string;
+});
 
 const ctorOf = (d: Declared): Ctor => (typeof d === 'function' ? d : d.ctor);
 
 /**
  * What a prefab was BUILT ON — `Presenter(Post)` and `Collector(User)` both keep it under
- * `__entity`, which is the only place it survives: nothing in the FORM of `PostPresenter`
- * says `Post`. Absent, the class did not come through the prefab, and the refusal says so
- * rather than yielding a frond whose presenter belongs to no entity.
+ * `__entity`, which is the only place it survives: nothing in the FORM of `PostPresenter` says
+ * `Post`.
  */
 function subjectOf(ctor: Ctor, kind: string): { name: string } {
   const subject = (ctor as unknown as { __entity?: { name: string } }).__entity;
@@ -72,6 +59,22 @@ function subjectOf(ctor: Ctor, kind: string): { name: string } {
 }
 const depsOf = (d: Declared): string[] => (typeof d === 'function' ? [] : d.deps ?? []);
 
+/**
+ * A Map either way — a statement is read as code, and an object literal is what code
+ * looks like there. What a prefab declares of itself is merged BELOW: a method the author
+ * wrote over `create` is the one that runs, so its contract is the one that answers.
+ */
+function statedOperations(h: Ctor | DeclaredHandler): Map<string, OperationContract> {
+  const declared = typeof h === 'function' ? undefined : h.operations;
+  const own = (ctorOf(h) as { __ops?: Record<string, OperationContract> }).__ops ?? {};
+  const merged = new Map<string, OperationContract>(Object.entries(own));
+  for (const [op, contract] of declared instanceof Map ? declared : Object.entries(declared ?? {})) {
+    merged.set(op, contract as OperationContract);
+  }
+
+  return merged;
+}
+
 /** `PostHandler` answers at `post` — the same rule the scan applies to a file it found. */
 function addressOf(className: string): string {
   const base = className.endsWith('Handler') ? className.slice(0, -7) : className;
@@ -91,17 +94,11 @@ export interface FrondDeclaration {
   surfaces?: Record<string, string[]>;
   /** The import scope this frond answers under. Defaults to the conventional one. */
   scope?: string;
+  /** What `frond.config.ts` states — the third producer of an operation contract. */
+  operationsOverrides?: FrondDescriptor['operationsOverrides'];
 }
 
-/**
- * State a frond without reading a disk.
- *
- * ```ts
- * createApp({
- *   scan: { fronds: Fronds.hosting([frond('blog', { entities: [Post], handlers: [PostHandler] })]), diagnostics: [] },
- * })
- * ```
- */
+/** State a frond without reading a disk. */
 export function frond(name: string, declared: FrondDeclaration = {}): FrondDescriptor {
   const scope = declared.scope ?? DEFAULT_CONVENTIONS.scope;
 
@@ -124,7 +121,7 @@ export function frond(name: string, declared: FrondDeclaration = {}): FrondDescr
       // A handler about no stored row is ordinary — the address is not a promise that an
       // entity carries it, which is why this is not looked up.
       entityName: address,
-      operations: new Map(),
+      operations: statedOperations(h),
       deps: depsOf(h),
       filePath: '',
       exposed: true,
@@ -163,6 +160,9 @@ export function frond(name: string, declared: FrondDeclaration = {}): FrondDescr
   });
 
   const providers: ProviderEntry[] = (declared.providers ?? []).map((p) => ({
+    // Written down where a statement says it, read off the class otherwise — the class's
+    // own name is what a bundler is free to rewrite.
+    ...(typeof p === 'function' || !p.name ? {} : { name: p.name }),
     ctor: ctorOf(p),
     deps: depsOf(p),
     filePath: '',
@@ -177,6 +177,7 @@ export function frond(name: string, declared: FrondDeclaration = {}): FrondDescr
   return {
     name,
     source: { path: '', package: `${scope}/${name}` },
+    ...(declared.operationsOverrides ? { operationsOverrides: declared.operationsOverrides } : {}),
     providers,
     entities,
     handlers,

package/src/define.ts

@@ -1,9 +1,8 @@
 import type { FougereConfig } from './config-loader.js';
 
 /**
- * Identity helper for fougere.config.ts — preserves literal types for autocomplete
- * while validating against FougereConfig. Equivalent to `satisfies FougereConfig`
- * but more explicit and aligned with defineFrond().
+ * Identity helper for fougere.config.ts — preserves literal types for autocomplete while
+ * validating against FougereConfig.
  */
 export function defineFougere<T extends FougereConfig>(config: T): T {
   return config;

package/src/descriptor/Fronds.ts

@@ -1,19 +1,7 @@
 import type { SchemaView } from '@fougere/schema';
 import type { EntityEntry, FrondDescriptor } from './frond.js';
 
-/**
- * What this app hosts, with the questions everyone was asking it by hand.
- *
- * The list was a bare array, so every reader re-walked it: "which frond owns this
- * entity" was spelled four times, "every entity by name" three times as three literal
- * copies of the same `Map`, and the two inside the boot even carried comments saying so.
- * A concept nobody can question is a concept everyone rebuilds.
- *
- * It IS an array — the same reason `ListResult` is one: twenty call sites iterate,
- * filter and spread it, and none of them is wrong to. `Symbol.species` is `Array` so a
- * `.map()` over it answers a plain array rather than something that claims to be a
- * hosting table and holds strings.
- */
+/** What this app hosts, with the questions everyone was asking it by hand. */
 export class Fronds extends Array<FrondDescriptor> {
   static override get [Symbol.species](): ArrayConstructor {
     return Array;
@@ -21,9 +9,9 @@ export class Fronds extends Array<FrondDescriptor> {
 
   /** The fronds an app hosts, scanned or stated. The only gate in — `Array.of` is taken. */
   static hosting(fronds: readonly FrondDescriptor[]): Fronds {
-    const held = new Fronds();
-    held.push(...fronds);
-    return held;
+    const all = new Fronds();
+    all.push(...fronds);
+    return all;
   }
 
   /** The frond that hosts an entity — `undefined` when no loaded frond does. */
@@ -40,13 +28,7 @@ export class Fronds extends Array<FrondDescriptor> {
     return undefined;
   }
 
-  /**
-   * Every entity class, by name — across all fronds and never per-frond.
-   *
-   * A fact is announced in one frond and heard in another, so the subscriber's own
-   * frond does not hold the shape it must judge; a `reads:` clause names entities
-   * that belong to neighbours by definition.
-   */
+  /** Every entity class, by name — across all fronds and never per-frond. */
   schemas(): Map<string, SchemaView> {
     return new Map(this.flatMap((frond) => frond.entities.map((e) => [e.name, e.entityClass] as const)));
   }
@@ -56,14 +38,7 @@ export class Fronds extends Array<FrondDescriptor> {
     return this.flatMap((frond) => frond.entities.map((e) => e.name)).sort();
   }
 
-  /**
-   * The names a call may address, sorted — what a NOT_FOUND must print.
-   *
-   * Not `entityNames()`, which is what the scan found: an entity with no handler is
-   * scanned and serves nothing, so the refusal read *"Entity 'indexed' is not hosted
-   * here. Hosted here: indexed."* — naming the very thing it had just refused. A façade
-   * is keyed on a HANDLER's address, and that is what this lists.
-   */
+  /** The names a call may address, sorted — what a NOT_FOUND must print. */
   servedNames(surface?: string): string[] {
     return this.flatMap((frond) => frond.handlers
       .filter((handler) => (handler.surface ?? undefined) === surface)

package/src/descriptor/frond.ts

@@ -1,33 +1,21 @@
-/**
- * What a frond is made of — one interface per convention directory.
- *
- * Produced two ways and indistinguishable once here: the scan DERIVES it from a
- * directory tree, `frond()` STATES it outright. `frond-config.ts` is the declared
- * side; they meet at `FrondDescriptor.operationsOverrides`.
- */
+/** What a frond is made of — one interface per convention directory. */
 import type { SchemaView } from '@fougere/schema';
 import type { Param, OperationContract, OperationsMap } from '../wire/operation.js';
 import type { PresenterViews } from '../prefab/presenter.js';
 import type { Fronds } from './Fronds.js';
 
-/**
- * A discovered provider — a class under `services/` or `repositories/`, injected by type.
- *
- * Which of the two directories it came from is deliberately not recorded. The scan used
- * to tag it `kind: 'service' | 'repository'`, a field it filled on every provider and
- * that **no consumer ever read** — the two directories are two spellings of the same
- * thing, and DI resolves by type either way.
- */
+/** A discovered provider — a class under `services/` or `repositories/`, injected by type. */
 export interface ProviderEntry {
   /**
-   * The class constructor (default export of the file).
+   * The container key — the class name as the SOURCE spells it.
    *
-   * `never[]` and not `unknown[]`: the arguments are the CONTAINER's to supply, so the
-   * slot must accept any constructor — and with `unknown[]` a real class is refused,
-   * because assigning it would need `unknown` to be one of its declared parameters.
-   * Invisible on the scan path, where the value arrives as `unknown` and is cast; the
-   * module `fougere build` writes states the class by name, and that is where it showed.
+   * Read at boot off `ctor.name` for a decade of no consequence, until a bundler lowered
+   * a `static readonly` field and renamed the declaration doing it: the provider
+   * registered as `_Communes` and the handler asking for `Communes` got a container miss.
+   * A name a tool may rewrite is written down, for the same reason `deps` is.
    */
+  name?: string;
+  /** The class constructor (default export of the file). */
   ctor: new (...args: never[]) => unknown;
   /** Constructor dependency type names (from AST scan). */
   deps: string[];
@@ -35,6 +23,12 @@ export interface ProviderEntry {
   filePath: string;
 }
 
+/**
+ * The key a provider answers under. What the source said, and the class's own name only
+ * where nobody wrote it down — a statement is read as code, and code can say it.
+ */
+export const nameOf = (provider: ProviderEntry): string => provider.name ?? provider.ctor.name;
+
 /** A discovered entity (Entity subclass in entities/ dir). */
 export interface EntityEntry {
   /** Registration key: class name lowercased first char (e.g. 'product'). */
@@ -52,16 +46,8 @@ export interface HandlerEntry {
   /** Registration key (e.g. 'postHandler'). */
   name: string;
   /**
-   * The name this handler answers to — its class name minus `Handler`, lowercased
-   * (`PostHandler` → `post`). It is what `facadeKeyOf` builds its key from and what
-   * travels as `FrondCall.entity` on the wire.
-   *
-   * **It is NOT an entity name**, and it was called `entityName` for long enough to
-   * mislead: `toEntityName` (`scanner.ts`) strips the suffix without checking that any
-   * entity carries the result, and the boot states the consequence — *pointing at
-   * nothing is legal*. A health check, a search across several shapes, a pure
-   * computation: ordinary handlers that own no row. `PresenterEntry`/`CollectorEntry`
-   * keep `entityName` because those really do target a declared entity.
+   * The name this handler answers to — its class name minus `Handler`, lowercased (`PostHandler` →
+   * `post`).
    */
   address: string;
   /** The handler class. */
@@ -85,25 +71,11 @@ export interface PresenterFieldMeta {
   name: string;
   /** Inferred return type name: 'string', 'number', 'boolean', or a class name. */
   returnType?: string;
-  /**
-   * The field emits a LIST per row — `tags(posts: Post[]): string[][]`.
-   *
-   * The method answers one value per row, so the outer array level of its return type is
-   * the page, not the field: what remains after removing it is the field's own arity.
-   * Nothing measured that remainder, so a computed list and a computed scalar looked
-   * identical and every projection announced the scalar.
-   */
+  /** The field emits a LIST per row — `tags(posts: Post[]): string[][]`. */
   list?: boolean;
   /** Whether the return is nullable. */
   nullable?: boolean;
-  /**
-   * The declared parameters AFTER the rows. Kept raw rather than resolved: the scan
-   * meets presenters before collectors, so the plan is computed at boot where the
-   * collector names are known — exactly as a handler op's is.
-   *
-   * A computed field that declares `user?: User` is then fed by the collector
-   * that resolves one. A presenter is not a second mechanism.
-   */
+  /** The declared parameters AFTER the rows. */
   params?: Param[];
 }
 
@@ -118,10 +90,8 @@ export interface PresenterEntry {
   /** Per-field type metadata (inferred from source via parser). */
   fieldMeta: PresenterFieldMeta[];
   /**
-   * The view each computed field emits, when the presenter declares one
-   * (`Presenter(Order, { items: [OrderItemView] })`). Stated rather than inferred: the
-   * parser reads a scalar off a return type and nothing more, so an object-valued field
-   * has no derivable shape without this.
+   * The view each computed field emits, when the presenter declares one (`Presenter(Order, {
+   * items: [OrderItemView] })`).
    */
   views?: PresenterViews;
   /** Constructor dependency type names (from AST scan). */
@@ -172,18 +142,14 @@ export interface FrondDescriptor {
   presenters: PresenterEntry[];
   collectors: CollectorEntry[];
   seeds: SeedEntry[];
-  /** Per-surface entity lists from frond.config.ts (e.g. { graphql: ['Post'], rest: ['Post', 'Author'] }). */
+  /**
+   * Per-surface entity lists from frond.config.ts (e.g. { graphql: ['Post'], rest: ['Post',
+   * 'Author'] }).
+   */
   surfaces?: Record<string, string[]>;
   /** Entities this frond may read across sources — see `FrondConfig.reads`. */
   reads?: string[];
-  /**
-   * Per-operation overrides from frond.config.ts. Key = operation name.
-   *
-   * Two depths, as declared on {@link OperationOverride}: the surface keys travel to the
-   * transport adapters, the contract keys (`input`/`output`/`binding`) travel to the
-   * façade — where config is the third producer of an operation's contract, alongside a
-   * prefab's `__ops` and the scan.
-   */
+  /** Per-operation overrides from frond.config.ts. */
   operationsOverrides?: Record<string, OperationContract & {
     kind?: 'query' | 'command';
     /** Class name to resolve from DI (overrides default `{Entity}Handler` lookup). */

package/src/dispatch/ArgumentResolver.ts

@@ -1,4 +1,4 @@
-import type { InvocationContext } from '../contract/Invocation.js';
+import type { InvocationContext } from '../wire/Invocation.js';
 import type { BindingPlan } from '../wire/binding.js';
 
 export interface CollectorResolver {
@@ -40,15 +40,15 @@ export class ArgumentResolver {
         }
         case 'fact': {
           // A fact IS the payload — the whole of what happened, never a piece of it.
-          // Identical to `body` today, and deliberately not sharing its branch: the two
-          // agree by coincidence, not by rule, and the day `body` learns to look up a
+          // Identical to `input` today, and deliberately not sharing its branch: the two
+          // agree by coincidence, not by rule, and the day `input` learns to look up a
           // value by parameter name a subscriber would receive ONE FIELD of the fact it
           // subscribed to. Splitting it costs nothing and removes that trap.
-          args.push(ctx.body);
+          args.push(ctx.input);
           break;
         }
-        case 'body': {
-          args.push(ctx.body);
+        case 'input': {
+          args.push(ctx.input);
           break;
         }
         case 'query': {

package/src/dispatch/DispatchEvent.ts

@@ -1,5 +1,5 @@
-import type { Call } from '../contract/Call.js';
-import type { RouteKind } from '../contract/RouteAddress.js';
+import type { Call } from '../wire/call.js';
+import type { RouteKind } from '../wire/RouteAddress.js';
 
 export type DispatchStage = 'received' | 'resolved' | 'completed' | 'failed' | 'settled';