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

package/src/contract.ts

@@ -53,6 +53,9 @@ export type { DeclaredEdge } from './wire/topology/DeclaredEdge.js';
 export type { DeclaredFrond } from './wire/topology/DeclaredFrond.js';
 export type { DeclaredTopology } from './wire/topology/DeclaredTopology.js';
 export type { Edge } from './wire/topology/Edge.js';
+export { OPERATION_KINDS, type OperationKind } from './wire/OperationKind.js';
+export { CARDINALITIES, type Cardinality } from './wire/Cardinality.js';
+export { PLACEMENTS, type Placement } from './wire/Placement.js';
 export type { FrondPlacement } from './wire/topology/FrondPlacement.js';
 export type { TopologyReport } from './wire/topology/TopologyReport.js';
 export { assertIdentityCard } from './wire/card/IdentityCard.js';

package/src/descriptor/CollectorEntry.ts

@@ -1,11 +1,6 @@
+import type { Subject } from './Subject.js';
 /** A discovered collector (resolves handler input params from invocation context). */
-export interface CollectorEntry {
+export interface CollectorEntry extends Subject {
   /** Registration key of the TYPE this collector resolves — 'user', 'ability'. */
   typeName: string;
-  /** The collector class. */
-  ctor: new (...args: never[]) => unknown;
-  /** Constructor dependency type names (from AST scan). */
-  deps: string[];
-  /** Absolute file path (for debugging). */
-  filePath: string;
 }

package/src/descriptor/FrondDescriptor.ts

@@ -1,4 +1,6 @@
 import type { OperationContract } from '../wire/OperationContract.js';
+import type { OperationOverride } from '../OperationOverride.js';
+import type { FrondConfig } from '../FrondConfig.js';
 import type { ProviderEntry } from './ProviderEntry.js';
 import type { EntityEntry } from './EntityEntry.js';
 import type { HandlerEntry } from './HandlerEntry.js';
@@ -15,7 +17,7 @@ import type { ExtensionEntry } from './ExtensionEntry.js';
  */
 export const nameOf = (provider: ProviderEntry): string => provider.name ?? provider.ctor.name;
 
-export interface FrondDescriptor {
+export interface FrondDescriptor extends Pick<FrondConfig, 'pipes' | 'surfaces' | 'reads'> {
   name: string;
   source: FrondSource;
   providers: ProviderEntry[];
@@ -41,26 +43,10 @@ export interface FrondDescriptor {
    * flat, and a directory says nothing about who shares its code.
    */
   extends?: string;
-  /** The ops that finish a fact, in order — see `FrondConfig.pipes`. */
-  pipes?: Record<string, string[]>;
-  /**
-   * 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. */
-  operationsOverrides?: Record<string, OperationContract & {
-    kind?: 'query' | 'command';
-    /** Class name to resolve from DI (overrides default `{Entity}Handler` lookup). */
+  operationsOverrides?: Record<string, OperationContract & Omit<OperationOverride, 'handler'> & {
+    /** The handler CLASS of `frond.config.ts`, by the name DI resolves it under. */
     handlerName?: string;
-    /** Method name on the resolved handler (defaults to op name). */
-    method?: string;
-    /** The GraphQL root field this op answers to — read by `adapter/graphql`. */
-    graphql?: string;
-    /** Where it answers over REST — read by `adapter/rest`, the dual of `graphql`. */
-    rest?: { method?: string; path?: string; status?: number };
   }>;
 }
 

package/src/descriptor/HandlerEntry.ts

@@ -1,8 +1,9 @@
+import type { Subject } from './Subject.js';
 import type { SchemaView } from '@fougere/schema';
 import type { OperationsMap } from '../wire/OperationsMap.js';
 
 /** A discovered handler (controls what a service exposes). */
-export interface HandlerEntry {
+export interface HandlerEntry extends Subject {
   /** Registration key (e.g. 'postHandler'). */
   name: string;
   /**
@@ -10,14 +11,8 @@ export interface HandlerEntry {
    * `post`).
    */
   address: string;
-  /** The handler class. */
-  ctor: new (...args: never[]) => unknown;
   /** All operations with full signatures for binding. */
   operations: OperationsMap;
-  /** Constructor dependency type names (from AST scan). */
-  deps: string[];
-  /** Absolute file path (for debugging). */
-  filePath: string;
   /** Whether this handler is part of the frond's public contract. */
   exposed?: boolean;
   /** Output schema override — when Crud(Entity, Output), restricts storage output. */

package/src/descriptor/MiddlewareEntry.ts

@@ -1,3 +1,4 @@
+import type { Subject } from './Subject.js';
 /**
  * A discovered middleware — a class declaring `around(ctx, next)`, which runs before and after
  * every operation of its frond, and of the fronds that inherit from it.
@@ -5,13 +6,7 @@
  * How far it reaches is not written here: it is where the frond sits in `FougereConfig.fronds`,
  * and stating it twice would put one decision in two places.
  */
-export interface MiddlewareEntry {
+export interface MiddlewareEntry extends Subject {
   /** Class name — the key it registers under in its frond's scope. */
   name: string;
-  /** The middleware class. */
-  ctor: new (...args: never[]) => unknown;
-  /** Constructor dependency type names (from AST scan). */
-  deps: string[];
-  /** Absolute file path (for debugging). */
-  filePath: string;
 }

package/src/descriptor/PresenterEntry.ts

@@ -1,12 +1,11 @@
+import type { Subject } from './Subject.js';
 import type { PresenterViews } from '../prefab/presenter.js';
 import type { PresenterFieldMeta } from './PresenterFieldMeta.js';
 
 /** A discovered presenter (computed fields for an entity's output). */
-export interface PresenterEntry {
+export interface PresenterEntry extends Subject {
   /** Entity name this presenter enriches (e.g. 'post' from PostPresenter). */
   entityName: string;
-  /** The presenter class. */
-  ctor: new (...args: never[]) => unknown;
   /** Computed field names (method names on prototype). */
   fields: string[];
   /** Per-field type metadata (inferred from source via parser). */
@@ -16,8 +15,4 @@ export interface PresenterEntry {
    * items: [OrderItemView] })`).
    */
   views?: PresenterViews;
-  /** Constructor dependency type names (from AST scan). */
-  deps: string[];
-  /** Absolute file path (for debugging). */
-  filePath: string;
 }

package/src/descriptor/ProviderEntry.ts

@@ -1,5 +1,6 @@
+import type { Subject } from './Subject.js';
 /** A discovered provider — a class under `services/` or `repositories/`, injected by type. */
-export interface ProviderEntry {
+export interface ProviderEntry extends Subject {
   /**
    * The container key — the class name as the SOURCE spells it.
    *
@@ -9,12 +10,6 @@ export interface ProviderEntry {
    * 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[];
-  /** Absolute file path (for debugging). */
-  filePath: string;
   /**
    * What the source said and the runtime erased: a port, which a class below answers for and
    * nothing may instantiate — never a candidate for the ports above it.

package/src/descriptor/Subject.ts

@@ -0,0 +1,10 @@
+import type { Ctor } from '../Ctor.js';
+
+/** A class the boot builds — what its constructor asks for, and where the scan found it. */
+export interface Subject {
+  ctor: Ctor;
+  /** Constructor dependency type names (from AST scan). */
+  deps: string[];
+  /** Absolute file path (for debugging). */
+  filePath: string;
+}

package/src/descriptor/index.ts

@@ -21,6 +21,7 @@ export { type OperationsMap } from '../wire/OperationsMap.js';
 export { type Param } from '../wire/Param.js';
 export { type TypeRef } from '../wire/TypeRef.js';
 export { computeBindingPlan, type BindingPlan } from '../wire/binding.js';
+export { opsOf } from '../prefab/opsOf.js';
 export type { Signature } from '../wire/Signature.js';
 export { awaitKeyOf, emitKeyOf } from '../wire/Emit.js';
 export { addressOf } from '../wire/Facade.js';

package/src/index.ts

@@ -63,6 +63,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 +82,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 +131,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';

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) =>
+  ({ name: 'id', source: { kind: 'param' as const, name: 'id', 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', identifies: { entity, field } } });
 
 const inputParam = (entity: string) => ({ name: 'input', type: { raw: `Partial<${entity}>`, name: entity } });
 
@@ -50,6 +52,8 @@ 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 id = byId(name);
+  const idSignature = idParam(name, FieldSet.of(entity.getFields()).primary ?? 'id');
 
   return {
     list: {
@@ -61,8 +65,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 +75,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 +107,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 +116,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 +127,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/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/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;
   /**

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];

package/src/wire/Placement.ts

@@ -0,0 +1,4 @@
+/** Where something answers — in this process, or a process away. */
+export const PLACEMENTS = ['local', 'remote'] as const;
+
+export type Placement = (typeof PLACEMENTS)[number];

package/src/wire/RouteKind.ts

@@ -1,2 +1,4 @@
+import type { Placement } from './Placement.js';
+
 /** Which kind of destination served a call — it travels in a `CallRecord`. */
-export type RouteKind = 'local' | 'remote' | 'system';
+export type RouteKind = Placement | 'system';

package/src/wire/StateShape.ts

@@ -1,4 +1,4 @@
-import { InputValidator, dotted, optional, type Field, type Fields } from '@fougere/schema';
+import { Schema, dotted, optional, type Field, type Fields, type SchemaConstructor, type SchemaView } from '@fougere/schema';
 import { ErrorCode } from './ErrorCode.js';
 import { FougereError } from './FougereError.js';
 
@@ -16,19 +16,16 @@ export interface StateDeclaration {
  * Documented: [collectors](https://fougere.dev/docs/business/collectors).
  */
 export class StateShape {
-  static readonly empty = new StateShape({});
+  static readonly empty = new StateShape(Schema.of({ fields: {} }));
 
-  private readonly validator: InputValidator;
-
-  private constructor(private readonly fields: Fields) {
-    this.validator = InputValidator.of(fields);
-  }
+  private constructor(private readonly schema: SchemaView) {}
 
   /** Two extensions declaring one member refuse: the field that judges it would depend on wiring order. */
   static of(declarations: readonly StateDeclaration[]): StateShape {
-    const fields: Fields = {};
     const owners = new Map<string, string>();
+    let schema: SchemaConstructor<Fields> = Schema.of({ fields: {} as Fields });
     for (const { name, state } of declarations) {
+      const fields: Fields = {};
       for (const [member, field] of Object.entries(state ?? {})) {
         const owner = owners.get(member);
         if (owner) {
@@ -40,9 +37,10 @@ export class StateShape {
         owners.set(member, name);
         fields[member] = optional(field);
       }
+      schema = schema.extend(fields);
     }
 
-    return new StateShape(fields);
+    return new StateShape(schema);
   }
 
   /**
@@ -58,10 +56,10 @@ export class StateShape {
     const written = Object.fromEntries(Object.entries(state).filter(([member, value]) => entered[member] !== value));
     if (Object.keys(written).length === 0) return state;
 
-    const result = this.validator.validate(written);
+    const result = this.schema.validate(written);
     if (result.success) return { ...state, ...result.data };
 
-    const declared = Object.keys(this.fields);
+    const declared = Object.keys(this.schema.getFields());
     const errors = result.errors.map((error) => ({ ...error, path: ['state', ...error.path] }));
 
     throw new FougereError({