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

package/src/boot/bootstrap.ts

@@ -1,4 +1,5 @@
 import { createContainer, type Container } from '@fougere/container';
+import { unregistered } from './unregistered.js';
 import { lowerFirst, type SchemaView } from '@fougere/schema';
 
 import type { HandlerEntry } from '../descriptor/HandlerEntry.js';
@@ -573,7 +574,7 @@ function answerRemotes(
   { container, routeRegistry, dispatcher, getMiddlewares, options, state }: Pick<Assembly, 'container' | 'routeRegistry' | 'dispatcher' | 'getMiddlewares' | 'options' | 'state'>,
   remoteRouter: RemoteRouter,
   fronds: Fronds,
-): void {
+): (name: string) => boolean {
   // Only for what another process may serve: an entity a frond hosts HERE and gives no handler
   // is served by nobody, and a stand-in for it had GraphQL project an entity with no operation.
   const servedElsewhere = (address: string): boolean => {
@@ -581,9 +582,8 @@ function answerRemotes(
 
     return owner === undefined || owner.name in (options.remotes ?? {});
   };
-  container.setFallback((name) => (isFacadeKey(name) && servedElsewhere(addressOf(name))
-    ? facadeOperations(dispatcher, addressOf(name))
-    : undefined));
+  const answeredElsewhere = (name: string): boolean => isFacadeKey(name) && servedElsewhere(addressOf(name));
+  container.setFallback((name) => (answeredElsewhere(name) ? facadeOperations(dispatcher, addressOf(name)) : undefined));
 
   const remoteFacades = new Map<string, Record<string, Function>>();
   routeRegistry.addResolver(remoteRoutes((address) => {
@@ -594,6 +594,8 @@ function answerRemotes(
 
     return facade;
   }));
+
+  return answeredElsewhere;
 }
 
 /** Refused rather than replaced: two declarations of one name would make the answer depend on wiring order. */
@@ -699,7 +701,7 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
     refuseWhatDoesNotHold(refused);
     markLineCarriers(emissions);
 
-    if (remoteRouter) answerRemotes(assembly, remoteRouter, fronds);
+    const answeredElsewhere = remoteRouter ? answerRemotes(assembly, remoteRouter, fronds) : () => false;
 
     const { resolve, schemaFor, facadeFor, operationsFor, presenterFor } = readings({
       container, fronds, remoteRouter, localDispatcher, routeRegistry, effectiveByKey, log,
@@ -740,6 +742,7 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
 
     built = app;
     await appLifecycle.up(app);
+    refuseWhatDoesNotHold(unregistered(container, fronds, answeredElsewhere));
     stopAnnouncing = announceLines(emissions, container, carry);
 
     return app;

package/src/boot/install.ts

@@ -285,13 +285,16 @@ function registerProviders(
   ownLogger: OwnLogger,
   frondLog: Logger,
 ): Map<string, ProviderEntry[]> {
-  for (const provider of frond.providers) {
-    scope.register(nameOf(provider), provider.ctor, { deps: ownLogger(nameOf(provider), provider.deps), ...lifetimeOf(provider.ctor) });
-  }
   // What this frond puts in front of one of the framework's own ports. Its own, like every
   // provider — a link goes where its frond goes, which is what a frond behind `remotes:`
-  // takes with it.
+  // takes with it. A link is built by `wrapping`, never by the container: it asks for the seam,
+  // and nothing answers that name.
   const seams = seamChains(frond.providers, ports, refused);
+  const links = new Set([...seams.values()].flat());
+  for (const provider of frond.providers) {
+    if (links.has(provider)) continue;
+    scope.register(nameOf(provider), provider.ctor, { deps: ownLogger(nameOf(provider), provider.deps), ...lifetimeOf(provider.ctor) });
+  }
   for (const [seam, links] of seams) {
     boundPorts.add(seam);
     frondLog.debug(`seam ${seam} → ${links.map((one) => one.ctor.name).join(' → ')} → the realization`);

package/src/boot/unregistered.ts

@@ -0,0 +1,40 @@
+import type { Container } from '@fougere/container';
+import type { Diagnostic } from '../diagnostic.js';
+import type { FrondDescriptor } from '../descriptor/FrondDescriptor.js';
+import { SEAMS } from './ports.js';
+
+/**
+ * What a constructor asks for and nothing where it is built answers — refused at boot rather than
+ * at its first call, once the extensions have risen, since `up` registers too. Read off what each
+ * class DECLARES, in the scope of the frond that declares it. A seam is answered by the link that
+ * wraps it, and a facade another process serves by the stand-in `answeredElsewhere` names.
+ */
+export function unregistered(
+  container: Container,
+  fronds: readonly FrondDescriptor[],
+  answeredElsewhere: (name: string) => boolean,
+): Diagnostic[] {
+  const refused = new Map<string, Diagnostic>();
+  for (const frond of fronds) {
+    if (!container.has(`frond:${frond.name}`)) continue;
+    const scope = container.resolve<Container>(`frond:${frond.name}`);
+    const declared = [...frond.handlers, ...frond.providers, ...frond.presenters, ...frond.collectors, ...frond.middlewares];
+    for (const { ctor, deps, filePath } of declared) {
+      for (const missing of deps) {
+        if (scope.has(missing) || SEAMS.has(missing) || answeredElsewhere(missing)) continue;
+        if (refused.has(`${ctor.name}→${missing}`)) continue;
+        refused.set(`${ctor.name}→${missing}`, {
+          severity: 'blocking',
+          code: 'dependency-unregistered',
+          frond: frond.name,
+          subject: ctor.name,
+          filePath,
+          message: `${ctor.name} asks for ${missing}, and nothing in frond '${frond.name}' or above it answers that name. `
+            + `A class of that name in a convention directory, or one extending it, would.`,
+        });
+      }
+    }
+  }
+
+  return [...refused.values()];
+}

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;