@fougere/core 0.17.4-alpha.0 → 0.19.0-alpha.0

package/src/dispatch/Facade.ts

@@ -5,6 +5,7 @@ import type { HandlerEntry } from '../descriptor/HandlerEntry.js';
 import type { PresenterEntry } from '../descriptor/PresenterEntry.js';
 import type { StateShape } from '../wire/StateShape.js';
 import type { OwnLogger } from '../builtin/OwnLoggers.js';
+import type { EntityLookup } from './EntityLookup.js';
 
 /** What boot resolved around one handler, beyond the handler and the scope it resolves in. */
 export interface Facade {
@@ -16,6 +17,8 @@ export interface Facade {
   handlers: readonly HandlerEntry[];
   /** The canonical operation table resolved before boot performs any side effect. */
   operations: EffectiveOperationsMap;
+  /** Where a parameter typed `Post['title']` finds the rules of `title`. */
+  entities: EntityLookup;
   /** Entity names this frond has a collector for. */
   collectors: Set<string>;
   /** The presenter over this handler's entity, when the frond declares one. */

package/src/dispatch/HandlerFacade.ts

@@ -35,9 +35,7 @@ export class HandlerFacade {
   private instance: any;
   private readonly implementationKeys = new Map<string, string>();
   private readonly implementationInstances = new Map<string, any>();
-  private readonly arguments = new ArgumentResolver(
-    (typeName) => this.collectorResolver(typeName),
-  );
+  private readonly arguments: ArgumentResolver;
   /** A computed field's parameters and the collectors in scope are both boot-time facts. */
   private readonly presenterPlans: Map<string, BindingPlan>;
 
@@ -52,6 +50,7 @@ export class HandlerFacade {
     private readonly facade: Facade,
   ) {
     this.refuseCrudWithoutRepository(handler);
+    this.arguments = new ArgumentResolver((typeName) => this.collectorResolver(typeName), facade.entities);
 
     this.presenterPlans = facade.presenter
       ? presenterPlans(facade.presenter, facade.collectors)
@@ -124,22 +123,31 @@ export class HandlerFacade {
     entered: Record<string, unknown>,
   ): Promise<unknown> {
     const state = this.facade.state.judge(context.state, this.handler.address, op, entered);
-    const validated = validateInput(contract.input, { ...invocation, state });
+    const written = invocation.args !== undefined;
+    const validated = written ? { ...invocation, state } : validateInput(contract.input, { ...invocation, state });
     context.invocation = validated;
 
-    const args = contract.binding ? await this.arguments.resolve(contract.binding, validated) : [];
+    const args = await this.argumentsOf(contract, validated);
     const { instance, method } = this.resolveImplementation(op);
     const answered = await instance[method](...args);
 
     const view = this.viewOf(op);
     const { presenter } = this.facade;
-    const computed = view.closed || !presenter
+    const computed = written || view.closed || !presenter
       ? answered
       : await this.present(op, presenter, answered, validated);
 
     return view.project(computed);
   }
 
+  /** What code wrote, judged; or what a door received, read through the binding plan. */
+  private async argumentsOf(contract: OperationContract, invocation: InvocationContext): Promise<unknown[]> {
+    if (!contract.binding) return [];
+    if (invocation.args !== undefined) return this.arguments.given(contract.binding, contract.input, invocation);
+
+    return this.arguments.resolve(contract.binding, invocation);
+  }
+
   /**
    * 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

package/src/entry/facade.ts

@@ -3,6 +3,7 @@ import { Call } from '../wire/Call.js';
 import { RouteAddress } from '../wire/RouteAddress.js';
 import type { DispatchPort } from '../dispatch/DispatchPort.js';
 import type { Received } from '../dispatch/Received.js';
+import type { PartialInvocation } from '../wire/PartialInvocation.js';
 
 type Operation = (...args: any[]) => unknown;
 
@@ -24,11 +25,14 @@ export function dynamicOperations(operation: (name: string) => Operation): Recor
 }
 
 /**
- * Turns facade method calls into canonical dispatches.
+ * The facade code calls: each operation takes the handler's own arguments.
  *
  * `received` is what this side puts back before handing the answer over: a row leaves as data
  * and `date-time` means a `Date` on both sides. A facade built without one hands over what the
  * wire carried, which is what a caller holding no schema can do.
+ *
+ * The trailing `undefined`s are dropped because a JSON array writes them `null`, and the far
+ * side would read a value where the caller left one out. An optional parameter is always last.
  */
 export function facadeOperations(
   dispatcher: DispatchPort,
@@ -37,7 +41,30 @@ export function facadeOperations(
   surface?: string,
   received?: Received,
 ): Record<string, Operation> {
-  const operation = (name: string): Operation => async (invocation) => {
+  const send = sending(dispatcher, address, surface, received);
+
+  return operationsOf((name) => (...args: unknown[]) => send(name, { args: withoutTrailingAbsence(args) }), operationNames);
+}
+
+/**
+ * What a door sends: the invocation it received, as a `Call`. A door holds a request, not the
+ * handler's arguments, so the binding plan reads it on the far side — collectors and presenter
+ * included.
+ */
+export function callOperations(
+  dispatcher: DispatchPort,
+  address: string,
+  operationNames?: Iterable<string>,
+  surface?: string,
+  received?: Received,
+): Record<string, Operation> {
+  const send = sending(dispatcher, address, surface, received);
+
+  return operationsOf((name) => (invocation?: PartialInvocation) => send(name, invocation), operationNames);
+}
+
+function sending(dispatcher: DispatchPort, address: string, surface?: string, received?: Received) {
+  return async (name: string, invocation?: PartialInvocation): Promise<unknown> => {
     const answer = await dispatcher.dispatch(new Call(
       new RouteAddress({
         address,
@@ -49,8 +76,17 @@ export function facadeOperations(
 
     return received ? received(name, answer) : answer;
   };
+}
 
+function operationsOf(operation: (name: string) => Operation, operationNames?: Iterable<string>): Record<string, Operation> {
   return operationNames
     ? Object.fromEntries([...operationNames].map((name) => [name, operation(name)]))
     : dynamicOperations(operation);
 }
+
+function withoutTrailingAbsence(args: unknown[]): unknown[] {
+  let length = args.length;
+  while (length > 0 && args[length - 1] === undefined) length--;
+
+  return args.slice(0, length);
+}

package/src/index.ts

@@ -23,6 +23,7 @@ export type { CrudConstructor } from './prefab/CrudConstructor.js';
 export type { CrudOpName } from './prefab/CrudOpName.js';
 export type { CrudOps } from './prefab/CrudOps.js';
 export type { CrudViews } from './prefab/CrudViews.js';
+export { Middleware } from './prefab/Middleware.js';
 export { Mirror } from './prefab/MirrorConstructor.js';
 export type { MirrorConstructor } from './prefab/MirrorConstructor.js';
 export type { MirrorOf } from './prefab/MirrorOf.js';
@@ -63,6 +64,7 @@ export type { AppMiddleware } from './wire/AppMiddleware.js';
 export type { AppNext } from './wire/AppNext.js';
 export type { OperationContext } from './wire/OperationContext.js';
 export { assertIdentityCard, RPC_ADDRESS, ENVELOPE_BYTES, maxBodyBytes, maxFrameBytes, setMaxBodyBytes } from './contract.js';
+export { OPERATION_KINDS, CARDINALITIES, PLACEMENTS, type OperationKind, type Cardinality, type Placement } from './contract.js';
 export { createLocalRunner, createAppRunner } from './boot/runner.js';
 
 // A frond an app STATES, for a boot that will not scan. No disk, no `typescript` — which
@@ -81,6 +83,7 @@ export { declaredTopologyOf } from './boot/declared.js';
 // Both halves of what a call can refuse, put together where they are READ — the framework's
 // follows from `kind` and `input`, so only the frond's travels.
 export { refusalsOf, type Refusable } from './wire/refusals.js';
+export type { Binding } from './Binding.js';
 // The facades as TYPES — empty here, filled by the `.d.ts` the scan writes beside the app.
 export type { Addresses } from './wire/Addresses.js';
 export type { Answer } from './wire/Answer.js';
@@ -129,7 +132,7 @@ export { Storage, togetherKeyOf } from './storage/Storage.js';
 export type { Constraint } from './Constraint.js';
 export type { Source } from './Source.js';
 export type { SourceConfig } from './SourceConfig.js';
-export type { SourceView } from './SourceView.js';
+export { sourceViewOf, type SourceView } from './SourceView.js';
 export { Sources } from './Source.js';
 export { storageOver } from './storage/Store.js';
 export type { Store } from './storage/Store.js';
@@ -138,6 +141,7 @@ export type { App } from './boot/App.js';
 export type { CreateAppOptions } from './boot/CreateAppOptions.js';
 export type { ScanResult } from './scan.js';
 export type { Diagnostic } from './diagnostic.js';
+export { BootRefusal } from './BootRefusal.js';
 export { DEFAULT_CONVENTIONS, frondDirsOf, frondPackage, providerDirsOf, resolveConventions, type Conventions } from './Conventions.js';
 export { type ConventionsInput } from './ConventionsInput.js';
 export type { CollectorEntry } from './descriptor/CollectorEntry.js';

package/src/prefab/AggregateConstructor.ts

@@ -1,7 +1,7 @@
 import type { AggregateShape } from './AggregateShape.js';
-import { type EntityConstructor } from '@fougere/schema';
+import { type Entity } from '@fougere/schema';
 
-export type AggregateConstructor<E extends readonly EntityConstructor[]> =
+export type AggregateConstructor<E extends readonly Entity[]> =
   (new (...storages: unknown[]) => AggregateShape<E>) & {
     readonly __entity: unknown;
     /** The entities this class owns. Present from two on — an owner of one owns nothing. */

package/src/prefab/AggregateOf.ts

@@ -1,6 +1,6 @@
-import { type EntityConstructor } from '@fougere/schema';
+import { type Entity } from '@fougere/schema';
 import type { Storage } from '../storage/Storage.js';
 
 /** The tuple an aggregate holds — the readable form of {@link AggregateShape}'s member. */
-export type AggregateOf<E extends readonly EntityConstructor[]> =
+export type AggregateOf<E extends readonly Entity[]> =
   { [K in keyof E]: Storage<InstanceType<E[K]>> };

package/src/prefab/AggregateShape.ts

@@ -1,7 +1,7 @@
 import type { Storage } from '../storage/Storage.js';
-import type { EntityConstructor } from '@fougere/schema';
+import type { Entity } from '@fougere/schema';
 
 /** What an aggregate's subclass sees. */
-export declare abstract class AggregateShape<E extends readonly EntityConstructor[]> {
+export declare abstract class AggregateShape<E extends readonly Entity[]> {
   protected storages: { [K in keyof E]: Storage<InstanceType<E[K]>> };
 }

package/src/prefab/CrudConstructor.ts

@@ -1,4 +1,4 @@
-import { lowerFirst, type EntityConstructor, type SchemaView } from '@fougere/schema';
+import { FieldSet, lowerFirst, type Entity, type SchemaView } from '@fougere/schema';
 import type { ListOptions } from '../storage/ListOptions.js';
 import type { Storage } from '../storage/Storage.js';
 import type { OperationContract } from '../wire/OperationContract.js';
@@ -29,13 +29,15 @@ export function subjectOf(ctor: unknown, address: string): string {
   return target?.name ? lowerFirst(target.name) : address;
 }
 
-/** The id of the row an op acts on — a route segment, or a query fallback. */
-const byId = { name: 'id', source: { kind: 'param' as const, name: 'id' }, optional: false };
+/** The id of the row an op acts on — `id: Post['id']`, which a route places before the op. */
+const byId = (entity: string, field: string) =>
+  ({ name: 'id', source: { kind: 'param' as const, name: 'id', field: { entity, name: field }, identifies: entity }, optional: false });
 
 const fromBody = { name: 'input', source: { kind: 'input' as const }, optional: false };
 
 /** The same five, written as the scan would have written them. */
-const idParam = { name: 'id', type: { raw: 'string', name: 'string' } };
+const idParam = (entity: string, field: string) =>
+  ({ name: 'id', type: { raw: `${entity}['${field}']`, name: 'string', field: { entity, name: field }, identifies: entity } });
 
 const inputParam = (entity: string) => ({ name: 'input', type: { raw: `Partial<${entity}>`, name: entity } });
 
@@ -50,6 +52,9 @@ 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);
+  const primary = FieldSet.of(entity.getFields()).primary ?? 'id';
+  const id = byId(name, primary);
+  const idSignature = idParam(name, primary);
 
   return {
     list: {
@@ -61,8 +66,8 @@ function crudOps(entity: SchemaView & { partial?: () => SchemaView }): Record<st
       },
     },
     findById: {
-      output: entity, cardinality: 'maybe', binding: [byId],
-      signature: { name: 'findById', returnType: returns(`${name} | undefined`, name, { nullable: true }), params: [idParam] },
+      output: entity, cardinality: 'maybe', binding: [id],
+      signature: { name: 'findById', returnType: returns(`${name} | undefined`, name, { nullable: true }), params: [idSignature] },
     },
     create: {
       input: entity, output: entity, cardinality: 'one', binding: [fromBody],
@@ -71,12 +76,12 @@ function crudOps(entity: SchemaView & { partial?: () => SchemaView }): Record<st
     // The patch view carries its own mode: an absent field is untouched, an
     // immutable one re-supplied is refused.
     update: {
-      input: entity.partial?.(), output: entity, cardinality: 'one', binding: [byId, fromBody],
-      signature: { name: 'update', returnType: returns(name, name), params: [idParam, input] },
+      input: entity.partial?.(), output: entity, cardinality: 'one', binding: [id, fromBody],
+      signature: { name: 'update', returnType: returns(name, name), params: [idSignature, input] },
     },
     delete: {
-      cardinality: 'none', binding: [byId],
-      signature: { name: 'delete', returnType: returns('boolean', 'boolean'), params: [idParam] },
+      cardinality: 'none', binding: [id],
+      signature: { name: 'delete', returnType: returns('boolean', 'boolean'), params: [idSignature] },
     },
   };
 }
@@ -103,7 +108,7 @@ export interface CrudConstructor<T, V = {}> {
  *
  * Documented: [handlers](https://fougere.dev/docs/business/handlers).
  */
-export function Crud<E extends EntityConstructor, V extends CrudViews | EntityConstructor = {}>(
+export function Crud<E extends Entity, V extends CrudViews | Entity = {}>(
   entity: E,
   output?: V,
 ): CrudConstructor<InstanceType<E>, V> {
@@ -112,7 +117,7 @@ export function Crud<E extends EntityConstructor, V extends CrudViews | EntityCo
 
   // A view is a class (it carries fields) ; a map of views is a plain object.
   const perOp = typeof output === 'object' && output !== null ? (output as CrudViews) : undefined;
-  const wholeHandler = typeof output === 'function' ? (output as EntityConstructor) : undefined;
+  const wholeHandler = typeof output === 'function' ? (output as Entity) : undefined;
 
   return asCrudConstructor<T, V>(class CrudHandler {
     static __entity = entity;
@@ -123,7 +128,7 @@ export function Crud<E extends EntityConstructor, V extends CrudViews | EntityCo
      * What this prefab handler declares — read by the façade, merged under the author's own
      * methods.
      */
-    static __ops: Record<string, OperationContract> = crudOps(entity as unknown as SchemaView & { partial?: () => SchemaView });
+    static __ops: Record<string, OperationContract> = crudOps(entity);
 
     // Private: the five ops are how a subclass reaches the rows — `super.findById(id)` — and a
     // query worth a name belongs to the repository, which it asks for like any handler does.

package/src/prefab/CrudOps.ts

@@ -1,5 +1,5 @@
 import type { CrudOpName } from './CrudOpName.js';
-import type { EntityConstructor } from '@fougere/schema';
+import type { Entity } from '@fougere/schema';
 import type { ListOptions } from '../storage/ListOptions.js';
 import type { Page } from '../wire/Page.js';
 
@@ -8,8 +8,8 @@ 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)
+  [V] extends [Entity] ? InstanceType<V & Entity>
+  : K extends keyof V ? (V[K] extends Entity ? InstanceType<V[K]> : T)
   : T;
 
 /** The five ops, typed from the entity and its views. */

package/src/prefab/CrudViews.ts

@@ -1,5 +1,5 @@
-import { type EntityConstructor } from '@fougere/schema';
+import { type Entity } from '@fougere/schema';
 import type { CrudOpName } from './CrudOpName.js';
 
 /** Which view each op speaks — omitted ops speak the entity, the trivial view. */
-export type CrudViews = Partial<Record<CrudOpName, EntityConstructor>>;
+export type CrudViews = Partial<Record<CrudOpName, Entity>>;

package/src/prefab/Middleware.ts

@@ -0,0 +1,13 @@
+import type { AppNext } from '../wire/AppNext.js';
+import type { OperationContext } from '../wire/OperationContext.js';
+
+/**
+ * What runs around every operation of its frond, and of the fronds under it — a class in
+ * `middlewares/` that extends this one.
+ *
+ * It answers what `next()` answered, the same type: a caller reads the handler's signature,
+ * and nothing tells that signature a middleware stood in the way.
+ */
+export abstract class Middleware {
+  abstract around<T>(context: OperationContext, next: AppNext<T>): Promise<T>;
+}

package/src/prefab/MirrorConstructor.ts

@@ -1,4 +1,4 @@
-import type { EntityConstructor } from '@fougere/schema';
+import type { Entity } from '@fougere/schema';
 import type { Storage } from '../storage/Storage.js';
 import type { Refreshed } from './Refreshed.js';
 import type { MirrorOf } from './MirrorOf.js';
@@ -8,7 +8,7 @@ export interface MirrorConstructor<T> {
   readonly __entity: unknown;
 }
 
-export function Mirror<E extends EntityConstructor>(shape: E): MirrorConstructor<InstanceType<E>> {
+export function Mirror<E extends Entity>(shape: E): MirrorConstructor<InstanceType<E>> {
   type T = InstanceType<E>;
 
   abstract class MirrorBase implements MirrorOf<T> {

package/src/prefab/RepositoryConstructor.ts

@@ -1,4 +1,4 @@
-import { upperFirst, type EntityConstructor } from '@fougere/schema';
+import { upperFirst, type Entity } from '@fougere/schema';
 import type { ListOptions } from '../storage/ListOptions.js';
 import type { ListResult } from '../storage/ListResult.js';
 import type { SelectOption } from '../storage/SelectOption.js';
@@ -14,22 +14,22 @@ export interface RepositoryConstructor<T> {
 }
 
 /** What an aggregate's subclass sees. */
-declare abstract class AggregateShape<E extends readonly EntityConstructor[]> {
+declare abstract class AggregateShape<E extends readonly Entity[]> {
   protected storages: { [K in keyof E]: Storage<InstanceType<E[K]>> };
 }
 
-export function Repository<E extends EntityConstructor>(entity: E): RepositoryConstructor<InstanceType<E>>;
+export function Repository<E extends Entity>(entity: E): RepositoryConstructor<InstanceType<E>>;
 
-export function Repository<E extends readonly [EntityConstructor, EntityConstructor, ...EntityConstructor[]]>(
+export function Repository<E extends readonly [Entity, Entity, ...Entity[]]>(
   ...entities: E
 ): AggregateConstructor<E>;
 
-export function Repository(...entities: EntityConstructor[]): unknown {
+export function Repository(...entities: Entity[]): unknown {
   return entities.length === 1 ? one(entities[0]) : many(entities);
 }
 
 /** The port forwarded, member by member. */
-function one<E extends EntityConstructor>(entity: E): RepositoryConstructor<InstanceType<E>> {
+function one<E extends Entity>(entity: E): RepositoryConstructor<InstanceType<E>> {
   type T = InstanceType<E>;
 
   class RepositoryBase implements Storage<T> {
@@ -56,7 +56,7 @@ function one<E extends EntityConstructor>(entity: E): RepositoryConstructor<Inst
 }
 
 /** The aggregate. */
-function many<E extends readonly EntityConstructor[]>(entities: E): AggregateConstructor<E> {
+function many<E extends readonly Entity[]>(entities: E): AggregateConstructor<E> {
   class AggregateBase {
     static readonly __entity = entities[0];
     static readonly __owns = entities;
@@ -77,6 +77,6 @@ export function repositoryKeyOf(entity: string): string {
 }
 
 /** The entities a class owns — empty for anything that is not an aggregate. */
-export function ownedBy(ctor: unknown): readonly EntityConstructor[] {
-  return (ctor as { __owns?: readonly EntityConstructor[] } | undefined)?.__owns ?? [];
+export function ownedBy(ctor: unknown): readonly Entity[] {
+  return (ctor as { __owns?: readonly Entity[] } | undefined)?.__owns ?? [];
 }

package/src/prefab/collector.ts

@@ -4,11 +4,12 @@
  * Documented: [collectors](https://fougere.dev/docs/business/collectors).
  */
 
-import { FieldValueValidator, dotted, json, upperFirst, type Field, type SchemaView } from '@fougere/schema';
+import type { AbstractCtor } from '../Ctor.js';
+import { FieldValueValidator, dotted, json, upperFirst, type Entity, type Field, type SchemaView } from '@fougere/schema';
 import { ErrorCode } from '../wire/ErrorCode.js';
 import { FougereError } from '../wire/FougereError.js';
 
-export function Collector<T extends abstract new (...args: any[]) => any>(target: T) {
+export function Collector<T extends AbstractCtor>(target: T) {
   class CollectorBase {
     static readonly __entity = target;
   }
@@ -34,7 +35,7 @@ export function collectedAs(collector: object, value: unknown): unknown {
 
   let reader = readers.get(target);
   if (!reader) {
-    reader = json(target as SchemaView & (new () => unknown));
+    reader = json(target as Entity);
     readers.set(target, reader);
   }
 

package/src/prefab/opsOf.ts

@@ -0,0 +1,6 @@
+import type { OperationContract } from '../wire/OperationContract.js';
+
+/** The contracts a class carries on itself — `Crud(Post)` states its five as `__ops`. */
+export function opsOf(ctor: unknown): Record<string, OperationContract> {
+  return (ctor as { __ops?: Record<string, OperationContract> }).__ops ?? {};
+}

package/src/prefab/prefab.ts

@@ -1,18 +1,18 @@
-import type { EntityConstructor } from '@fougere/schema';
+import type { Entity } from '@fougere/schema';
 import type { PresenterViews } from './presenter.js';
 
 /** What a prefab class declares about ITSELF, at runtime. */
 interface Prefab {
   /** The shape this class was built on. `Mirror` calls it a shape; it is the same slot. */
-  readonly __entity?: EntityConstructor;
+  readonly __entity?: Entity;
   /** The view each computed field emits — `Presenter(Order, { items: [OrderItemView] })`. */
   readonly __views?: PresenterViews;
   /** The view the whole handler speaks — `Crud(Post, PostPublic)`. Same slot, one level up. */
-  readonly __output?: EntityConstructor;
+  readonly __output?: Entity;
 }
 
 /** The shape a prefab was built on, or `undefined` when the class is not one. */
-export function targetOf(ctor: unknown): EntityConstructor | undefined {
+export function targetOf(ctor: unknown): Entity | undefined {
   return (ctor as Prefab | undefined)?.__entity;
 }
 
@@ -22,6 +22,6 @@ export function viewsOf(ctor: unknown): PresenterViews | undefined {
 }
 
 /** The handler-wide view a prefab declares, same rule. */
-export function outputOf(ctor: unknown): EntityConstructor | undefined {
+export function outputOf(ctor: unknown): Entity | undefined {
   return (ctor as Prefab | undefined)?.__output;
 }

package/src/prefab/presenter.ts

@@ -4,16 +4,16 @@
  * Documented: [presenters](https://fougere.dev/docs/business/presenters).
  */
 
-import { upperFirst, type EntityConstructor } from '@fougere/schema';
+import { upperFirst, type Entity } from '@fougere/schema';
 
 /**
  * The view a computed field emits — `OrderItemView` for one, `[OrderItemView]` for many.
  * A view is a schema, so it derives: `Order.pick('id', 'status')`, never a hand-written type.
  */
-export type PresenterViews = Record<string, EntityConstructor | [EntityConstructor]>;
+export type PresenterViews = Record<string, Entity | [Entity]>;
 
 /** `Presenter(Order, { items: [OrderItemView] })` — the views its computed fields emit. */
-export function Presenter<E extends EntityConstructor>(entity: E, views?: PresenterViews) {
+export function Presenter<E extends Entity>(entity: E, views?: PresenterViews) {
   class PresenterBase {
     static readonly __entity = entity;
     static readonly __views = views;

package/src/wire/Addresses.ts

@@ -1,17 +1,17 @@
 import type { FougereOperations } from './FougereOperations.js';
 
-type Served = keyof FougereOperations & string;
+type Generated = keyof FougereOperations & string;
 
 /**
  * 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'`
+ * conditional distribute: `Generated` 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;
 
 /**
  * The addresses this app answers at — or any string, until a scan has said otherwise. The
- * `[Served] extends [never]` form is what keeps an ungenerated project compiling: a bare `never`
+ * `[Generated] extends [never]` form is what keeps an ungenerated project compiling: a bare `never`
  * in a parameter position refuses every call, the correct ones included.
  */
-export type Addresses = [Served] extends [never] ? string : AddressIn<Served>;
+export type Addresses = [Generated] extends [never] ? string : AddressIn<Generated>;

package/src/wire/Cardinality.ts

@@ -0,0 +1,4 @@
+/** How MUCH an operation answers — the half of a return type that a view cannot say. */
+export const CARDINALITIES = ['one', 'maybe', 'many', 'page', 'none'] as const;
+
+export type Cardinality = (typeof CARDINALITIES)[number];

package/src/wire/Facade.ts

@@ -1,23 +1,20 @@
 import { lowerFirst } from '@fougere/schema';
 
-import type { InvocationContext } from './InvocationContext.js';
-
 /**
  * The facade built in front of a handler — the framework's second port, after `Storage`.
  *
- * What the handler knows is WHICH operations exist and what each one answers. The two ends are
- * the port's own: an invocation goes in where the handler takes positional arguments, and a
- * promise comes back where the handler may answer a bare value. A facade is a crossing, and a
- * crossing is awaited before any transport — the dispatch resolves a route, runs the middlewares
- * and awaits the collectors, so `readLocation(): string` was typed as answering now and never did.
+ * It takes what the handler takes: code calling it already holds the values, so nothing is
+ * collected for it and nothing is presented — that is a door's work, done on what a door
+ * received. A promise comes back where the handler may answer a bare value, because a facade
+ * is a crossing and a crossing is awaited, whether or not a transport carries it.
  *
  * `Awaited` because a promise does not stack: `Promise.resolve(p)` IS `p`, so writing
  * `Promise<R>` over an async handler would describe a `Promise<Promise<Post>>` that no value can
  * have — `.then` would hand its callback a promise the runtime never delivers.
  */
 export type Facade<T> = {
-  [K in keyof T]: T[K] extends (...args: never[]) => infer R
-    ? (invocation?: InvocationContext) => Promise<Awaited<R>>
+  [K in keyof T]: T[K] extends (...args: infer A) => infer R
+    ? (...args: A) => Promise<Awaited<R>>
     : never;
 };
 

package/src/wire/Invocation.ts

@@ -31,6 +31,7 @@ export class Invocation implements InvocationContext {
   readonly params: Record<string, unknown>;
   readonly query: Record<string, unknown>;
   readonly input: unknown;
+  readonly args?: readonly unknown[];
   readonly state: Record<string, unknown>;
   readonly trace?: string;
   readonly identity?: string;
@@ -38,11 +39,12 @@ export class Invocation implements InvocationContext {
   readonly runAt?: number;
   readonly crossed?: true;
 
-  /** Gives every entry and every transport the same nine-member value, frozen. */
+  /** Gives every entry and every transport the same ten-member value, frozen. */
   private constructor(context: PartialInvocation) {
     this.params = canonicalRecord(context.params);
     this.query = canonicalRecord(context.query);
     this.input = canonicalValue(context.input);
+    if (context.args !== undefined) this.args = canonicalValue(context.args) as readonly unknown[];
     // State is host-owned and may still be enriched by existing middlewares. Moving it
     // to immutable lifecycle context is a separate migration.
     this.state = context.state ?? {};

package/src/wire/InvocationContext.ts

@@ -2,6 +2,12 @@ export interface InvocationContext {
   params: Record<string, unknown>;
   query: Record<string, unknown>;
   input: unknown;
+  /**
+   * The handler's own arguments, written by code that called its facade. A door writes
+   * `params`, `query` and `input` — what it received — and the binding plan reads them; code
+   * already holds the values, so nothing is collected and nothing is presented.
+   */
+  args?: readonly unknown[];
   state: Record<string, unknown>;
   trace?: string;
   identity?: string;

package/src/wire/OperationContract.ts

@@ -5,6 +5,7 @@ import type { TypeRef } from './TypeRef.js';
 import type { ErrorCode } from './ErrorCode.js';
 import type { OperationKind } from './OperationKind.js';
 import type { OperationKindInference } from './OperationKindInference.js';
+import type { Cardinality } from './Cardinality.js';
 
 /** The contract of one operation — everything the façade needs to serve a call. */
 export interface OperationContract {
@@ -17,7 +18,7 @@ export interface OperationContract {
   /** The operation in words, for a caller that meets it over the wire and has to choose. */
   description?: string;
   /** How MUCH comes back — the half of the return type that `output` cannot say. */
-  cardinality?: 'one' | 'maybe' | 'many' | 'page' | 'none';
+  cardinality?: Cardinality;
   /** The argument names and TYPES — the one thing `binding` cannot say. */
   signature?: Signature;
   /**
@@ -48,8 +49,8 @@ const PRIMITIVE_RETURNS = new Set(['boolean', 'string', 'number', 'void', 'undef
 
 /** Deliberately finite. */
 const QUERY_VERBS = new Set([
-  'all', 'check', 'count', 'exists', 'fetch', 'find', 'get', 'has', 'health', 'list',
-  'load', 'mine', 'ping', 'quote', 'read', 'search', 'stats', 'status', 'who',
+  'all', 'can', 'check', 'count', 'exists', 'fetch', 'find', 'get', 'has', 'health', 'is',
+  'list', 'load', 'mine', 'ping', 'quote', 'read', 'search', 'stats', 'status', 'who',
 ]);
 
 /**

package/src/wire/OperationKind.ts

@@ -1 +1,4 @@
-export type OperationKind = 'query' | 'command';
+/** `query` reads, `command` writes — the same call REST turns into GET vs POST. */
+export const OPERATION_KINDS = ['query', 'command'] as const;
+
+export type OperationKind = (typeof OPERATION_KINDS)[number];