@fougere/core 0.9.3-alpha.0 → 0.10.0-alpha.0

package/src/dispatch/HandlerFacade.ts

@@ -1,51 +1,33 @@
 import type { Fields } from '@fougere/schema';
 import type { Container } from '@fougere/container';
-import {
-  runMiddlewares,
-  type AppMiddleware,
-  type OperationContext,
-} from '../wire/middleware.js';
-import type { CollectorResolver } from './ArgumentResolver.js';
+import { runMiddlewares } from '../wire/AppMiddleware.js';
+import { type OperationContext } from '../wire/OperationContext.js';
+import type { CollectorResolver } from './CollectorResolver.js';
 import { collectorKeyOf } from '../prefab/collector.js';
-import { inheritsCrud, subjectOf } from '../prefab/crud.js';
+import { inheritsCrud, subjectOf } from '../prefab/CrudConstructor.js';
 import { presenterKeyOf } from '../prefab/presenter.js';
-import { repositoryKeyOf } from '../prefab/repository.js';
-import type { OperationContract, OperationsMap } from '../wire/operation.js';
-import type { EffectiveOperation, EffectiveOperationsMap } from '../effective-operation.js';
+import { repositoryKeyOf } from '../prefab/RepositoryConstructor.js';
+import type { OperationContract } from '../wire/OperationContract.js';
+import type { OperationsMap } from '../wire/OperationsMap.js';
+import type { EffectiveOperation } from '../EffectiveOperation.js';
+import type { EffectiveOperationsMap } from '../EffectiveOperationsMap.js';
 import type { BindingPlan } from '../wire/binding.js';
-import { Invocation, type InvocationContext } from '../wire/Invocation.js';
-import type { HandlerEntry, PresenterEntry } from '../descriptor/frond.js';
+import { Invocation } from '../wire/Invocation.js';
+import { type InvocationContext } from '../wire/InvocationContext.js';
+import type { HandlerEntry } from '../descriptor/HandlerEntry.js';
+import type { PresenterEntry } from '../descriptor/PresenterEntry.js';
 import { ArgumentResolver } from './ArgumentResolver.js';
 import { OutputView } from './OutputView.js';
 import { PresenterExecutor } from './PresenterExecutor.js';
 import { presenterArguments, presenterPlans } from './presenterArguments.js';
 import { validateInput } from './validateInput.js';
+import type { Facade } from './Facade.js';
 
-/** What boot resolved around one handler, beyond the handler and the scope it resolves in. */
-export interface Door {
-  /** The container key this door answers under. */
-  key: string;
-  /** The frond this door belongs to — travels on every OperationContext. */
-  frond: string;
-  /** Handlers in the owning frond, used to realize a resolved implementation override. */
-  handlers: readonly HandlerEntry[];
-  /** The canonical operation table resolved before boot performs any side effect. */
-  operations: EffectiveOperationsMap;
-  /** Entity names this frond has a collector for. */
-  collectors: Set<string>;
-  /** The presenter over this handler's entity, when the frond declares one. */
-  presenter: PresenterEntry | undefined;
-  /** Presenters live in the frond's own scope, whatever sub-scope this door resolves in. */
-  presenterScope: Container;
-  /** The middlewares that apply to this address, read at call time and never at boot. */
-  middlewares: () => AppMiddleware[];
-}
-
-/** Adapts one handler door to executable operations. */
+/** Adapts one handler facade to executable operations. */
 export class HandlerFacade {
   /** Rich operation facts shared with check, explain and adapters. */
   readonly effectiveOperations: EffectiveOperationsMap;
-  /** Contracts served by this door. */
+  /** Contracts served by this facade. */
   readonly contracts: OperationsMap;
 
   private readonly cachedViews = new Map<string, OutputView>();
@@ -61,24 +43,24 @@ export class HandlerFacade {
   constructor(
     private readonly handler: HandlerEntry,
     private readonly scope: Container,
-    private readonly door: Door,
+    private readonly facade: Facade,
   ) {
     this.refuseCrudWithoutRepository(handler);
 
-    this.presenterPlans = door.presenter
-      ? presenterPlans(door.presenter, door.collectors)
+    this.presenterPlans = facade.presenter
+      ? presenterPlans(facade.presenter, facade.collectors)
       : new Map();
 
     scope.register(this.handlerKey, handler.ctor, { deps: this.depsOf(handler) });
 
-    this.effectiveOperations = door.operations;
+    this.effectiveOperations = facade.operations;
     this.contracts = new Map(
-      [...door.operations].map(([name, operation]) => [name, operation as OperationContract] as const),
+      [...facade.operations].map(([name, operation]) => [name, operation as OperationContract] as const),
     );
     handler.operations = this.contracts;
 
     // Register model-selected implementations in the same execution scope.
-    for (const [name, operation] of door.operations) {
+    for (const [name, operation] of facade.operations) {
       if (this.isBaseImplementation(operation)) continue;
       const implementation = this.implementationHandler(name);
       this.refuseCrudWithoutRepository(implementation);
@@ -104,14 +86,14 @@ export class HandlerFacade {
     const invocation = Invocation.from(input);
     const context: OperationContext = {
       entity,
-      frond: this.door.frond,
+      frond: this.facade.frond,
       operation: op,
       args: [],
       state: invocation.state,
       invocation,
     };
 
-    return runMiddlewares(this.door.middlewares(), context, async () => {
+    return runMiddlewares(this.facade.middlewares(), context, async () => {
       const validated = validateInput(contract.input, invocation, entity, op);
       context.invocation = validated;
 
@@ -122,7 +104,7 @@ export class HandlerFacade {
       const view = this.viewOf(op);
       const output = view.project(await instance[method](...args));
 
-      const { presenter } = this.door;
+      const { presenter } = this.facade;
       return view.closed || !presenter ? output : this.present(op, presenter, output, validated);
     });
   }
@@ -136,7 +118,7 @@ export class HandlerFacade {
   ): Promise<unknown> {
     const entity = this.handler.address;
     const executor = new PresenterExecutor(
-      this.door.presenterScope.resolve(presenterKeyOf(entity)),
+      this.facade.presenterScope.resolve(presenterKeyOf(entity)),
       presenter.fields,
       entity,
       op,
@@ -147,7 +129,7 @@ export class HandlerFacade {
   }
 
   private get handlerKey(): string {
-    return `_handler:${this.door.key}`;
+    return `_handler:${this.facade.key}`;
   }
 
   private depsOf(handler: HandlerEntry): string[] {
@@ -206,7 +188,7 @@ export class HandlerFacade {
   /** The exact handler entry the pure model selected; no name-only retry or fallback. */
   private implementationHandler(operationName: string): HandlerEntry {
     const operation = this.effectiveOperations.get(operationName)!;
-    const matches = this.door.handlers.filter((handler) =>
+    const matches = this.facade.handlers.filter((handler) =>
       handler.ctor.name === operation.implementation.className
       && handler.address === operation.implementation.address
       && handler.filePath === operation.implementation.filePath);

package/src/dispatch/InFlight.ts

@@ -1,4 +1,5 @@
-import { FougereError, ErrorCode } from '../wire/errors.js';
+import { ErrorCode } from '../wire/ErrorCode.js';
+import { FougereError } from '../wire/FougereError.js';
 
 /** Controls dispatch admission and signals when every accepted call has settled. */
 export class InFlight {

package/src/dispatch/LocalRoutePolicy.ts

@@ -1,5 +1,6 @@
-import type { Call } from '../wire/call.js';
-import { ErrorCode, FougereError } from '../wire/errors.js';
+import type { Call } from '../wire/Call.js';
+import { ErrorCode } from '../wire/ErrorCode.js';
+import { FougereError } from '../wire/FougereError.js';
 import type { Route } from './Route.js';
 import type { RoutePolicy } from './RoutePolicy.js';
 import { routeNotFound, servedOperations } from './routeNotFound.js';

package/src/dispatch/OperationRoute.ts

@@ -1,8 +1,7 @@
-import type { Call } from '../wire/call.js';
+import type { Call } from '../wire/Call.js';
 import type { RouteAddress } from '../wire/RouteAddress.js';
 import type { Route } from './Route.js';
-
-export type RouteExecution = (call: Call) => unknown | Promise<unknown>;
+import type { RouteExecution } from './RouteExecution.js';
 
 /** One executable route, distinguished by its routing kind. */
 export class OperationRoute implements Route {

package/src/dispatch/PresenterArgs.ts

@@ -0,0 +1 @@
+export type PresenterArgs = Record<string, unknown[]>;

package/src/dispatch/PresenterExecutor.ts

@@ -1,7 +1,7 @@
-import { ErrorCode, FougereError } from '../wire/errors.js';
+import { ErrorCode } from '../wire/ErrorCode.js';
+import { FougereError } from '../wire/FougereError.js';
 import { preserveArrayProperties } from './ArrayResult.js';
-
-export type PresenterArgs = Record<string, unknown[]>;
+import type { PresenterArgs } from './PresenterArgs.js';
 
 /** Adds a presenter's computed fields after output projection. */
 export class PresenterExecutor {

package/src/dispatch/Route.ts

@@ -1,5 +1,6 @@
-import type { Call } from '../wire/call.js';
-import type { RouteAddress, RouteKind } from '../wire/RouteAddress.js';
+import type { Call } from '../wire/Call.js';
+import type { RouteAddress } from '../wire/RouteAddress.js';
+import type { RouteKind } from '../wire/RouteKind.js';
 
 /** Executable destination known by the dispatcher. */
 export interface Route {

package/src/dispatch/RouteExecution.ts

@@ -0,0 +1,3 @@
+import type { Call } from '../wire/Call.js';
+
+export type RouteExecution = (call: Call) => unknown | Promise<unknown>;

package/src/dispatch/RoutePolicy.ts

@@ -1,4 +1,4 @@
-import type { Call } from '../wire/call.js';
+import type { Call } from '../wire/Call.js';
 import type { Route } from './Route.js';
 
 /** Restricts which registered routes one dispatch capability may enter. */

package/src/dispatch/StorageGuard.ts

@@ -1,7 +1,9 @@
 import { FieldSet, FieldValueValidator, InputRefusal, type Fields } from '@fougere/schema';
-import { COMPARISONS, comparisonOf, unknownIn } from '../storage/criterion.js';
-import { assertListOptions } from '../storage/port.js';
-import { ErrorCode, FougereError } from '../wire/errors.js';
+import { COMPARISONS, comparisonOf, unknownIn } from '../storage/Comparison.js';
+import { assertListOptions } from '../storage/Storage.js';
+import { ErrorCode } from '../wire/ErrorCode.js';
+import { FougereError } from '../wire/FougereError.js';
+import type { GuardReport } from './GuardReport.js';
 
 /** The gestures this guard grafts onto. */
 interface Writer {
@@ -12,14 +14,6 @@ interface Writer {
   list?(...args: unknown[]): unknown;
 }
 
-/** What a guard says about a filter it let through. The boot owns the voice. */
-export interface GuardReport {
-  /** The fields this door hands back, when it hands back fewer than the entity has. */
-  view?: Fields;
-  /** Said once per field — a filter is not a write, and a warning per call is noise. */
-  outOfView?: (message: string) => void;
-}
-
 /** Judges storage writes and list options without narrowing the storage interface. */
 export class StorageGuard {
   /** What has already been said, so a filter in a loop says it once. */
@@ -81,7 +75,7 @@ export class StorageGuard {
   }
 
   /**
-   * The values this write carries, validated and handed on PARSED — the rule the client door
+   * The values this write carries, validated and handed on PARSED — the rule the client facade
    * already holds (`InputValidator`), applied to a write that never passed through it. What a
    * handler is allowed to write is not asked here: only the value is.
    */
@@ -92,11 +86,11 @@ export class StorageGuard {
   }
 
   /**
-   * What a read may ask for. The write door judges what LANDS in a row; this one judges
+   * What a read may ask for. The write facade judges what LANDS in a row; this one judges
    * what a caller says about one — and it was the single entrance to the port with no
    * judge at all, while `params.filter` from a browser reaches it verbatim.
    *
-   * A criterion may name a SET, which is the one thing the write door would refuse: an
+   * A criterion may name a SET, which is the one thing the write facade would refuse: an
    * array is judged member by member, since that is what `IN` binds.
    */
   private criteria(where: Record<string, unknown>): Record<string, unknown> {
@@ -110,7 +104,7 @@ export class StorageGuard {
         continue;
       }
       // A comparison names its own vocabulary, and a typo in it would otherwise be a
-      // criterion that filters nothing — the silent truncation this door exists to stop.
+      // criterion that filters nothing — the silent truncation this facade exists to stop.
       const comparison = comparisonOf(field, asked);
       if (comparison) {
         const unknown = unknownIn(comparison);
@@ -148,11 +142,11 @@ export class StorageGuard {
   }
 
   /**
-   * A filter on a field this door does not hand back.
+   * A filter on a field this facade does not hand back.
    *
    * `output(schema)` narrows what is RETURNED and has never narrowed what is asked, so a
    * caller can already sort a hidden column into existence one comparison at a time — and
-   * the admin door copies a browser's filter here verbatim. Said rather than refused: it
+   * the admin facade copies a browser's filter here verbatim. Said rather than refused: it
    * is legal today, GraphQL batches a relation on a key a view may not carry, and a
    * refusal would break that on the way to fixing this.
    */
@@ -161,7 +155,7 @@ export class StorageGuard {
     if (!view || view[field] || this.said.has(field)) return;
     this.said.add(field);
     this.report.outOfView?.(
-      `${this.entity}.list() filtered on '${field}', which this door does not hand back — `
+      `${this.entity}.list() filtered on '${field}', which this facade does not hand back — `
       + 'a filter on a hidden field answers questions about it one call at a time.',
     );
   }
@@ -182,7 +176,7 @@ export class StorageGuard {
     for (const [key, item] of Object.entries(value as Record<string, unknown>)) {
       const field = this.fields[key];
       // A key the entity does not declare has no column to land in and no judge to pass:
-      // on the client door it is a typo, and on this one it is a mapping that went stale.
+      // on the client facade it is a typo, and on this one it is a mapping that went stale.
       if (!field) {
         errors.push(`${where}${key}: ${InputRefusal.unknownField}`);
         continue;

package/src/dispatch/presenterArguments.ts

@@ -1,8 +1,8 @@
 import { computeBindingPlan, type BindingPlan } from '../wire/binding.js';
-import type { InvocationContext } from '../wire/Invocation.js';
-import type { PresenterEntry } from '../descriptor/frond.js';
+import type { InvocationContext } from '../wire/InvocationContext.js';
+import type { PresenterEntry } from '../descriptor/PresenterEntry.js';
 import type { ArgumentResolver } from './ArgumentResolver.js';
-import type { PresenterArgs } from './PresenterExecutor.js';
+import type { PresenterArgs } from './PresenterArgs.js';
 
 /**
  * Where each computed field's extra arguments come from — read off the declaration, so a

package/src/dispatch/routeNotFound.ts

@@ -1,5 +1,6 @@
-import type { Call } from '../wire/call.js';
-import { ErrorCode, FougereError } from '../wire/errors.js';
+import type { Call } from '../wire/Call.js';
+import { ErrorCode } from '../wire/ErrorCode.js';
+import { FougereError } from '../wire/FougereError.js';
 import type { Route } from './Route.js';
 import type { RoutePolicy } from './RoutePolicy.js';
 

package/src/dispatch/validateInput.ts

@@ -1,6 +1,7 @@
 import { InputValidator, dotted, type SchemaView } from '@fougere/schema';
-import type { InvocationContext } from '../wire/Invocation.js';
-import { ErrorCode, FougereError } from '../wire/errors.js';
+import type { InvocationContext } from '../wire/InvocationContext.js';
+import { ErrorCode } from '../wire/ErrorCode.js';
+import { FougereError } from '../wire/FougereError.js';
 
 /** Validates and decodes the input declared by one operation contract. */
 export function validateInput(

package/src/entry/facade.ts

@@ -1,5 +1,5 @@
-import { Call } from '../wire/call.js';
-import type { PartialInvocation } from '../wire/Invocation.js';
+import { Call } from '../wire/Call.js';
+
 import { RouteAddress } from '../wire/RouteAddress.js';
 import type { DispatchPort } from '../dispatch/DispatchPort.js';
 

package/src/entry/transport.ts

@@ -1,7 +1,7 @@
-import { Call } from '../wire/call.js';
+import { Call } from '../wire/Call.js';
 import { RouteAddress } from '../wire/RouteAddress.js';
 import type { DispatchPort } from '../dispatch/DispatchPort.js';
-import type { Transport } from '../wire/call.js';
+import type { Transport } from '../wire/Transport.js';
 
 /** Adapts the historical transport signature to the canonical dispatch port. */
 export function createTransportEntry(dispatcher: DispatchPort, surface?: string): Transport {

package/src/index.ts

@@ -2,19 +2,35 @@
 export { createApp } from './boot/bootstrap.js';
 export { orderSeeds, runSeeds, seeding } from './boot/seed.js';
 export { AppLifecycle, migrating } from './boot/AppLifecycle.js';
-export type { Extension } from './boot/AppLifecycle.js';
+export type { Extension } from './boot/Extension.js';
 export { defineFougere } from './define.js';
-export type { FougereConfig, AdapterConfig } from './config-loader.js';
-export type { OperationOverride, FrondConfig } from './frond-config.js';
-export { buildGraph, clusterEntities, suggestSplit, type EntityNode, type DomainCluster } from './graph.js';
-export { Crud } from './prefab/crud.js';
-export type { CrudViews, CrudOps, CrudOpName, CrudConstructor } from './prefab/crud.js';
-export { Mirror } from './prefab/mirror.js';
-export type { Refreshed, MirrorOf, MirrorConstructor } from './prefab/mirror.js';
+export type { AdapterConfig } from './AdapterConfig.js';
+export type { FougereConfig } from './FougereConfig.js';
+export type { AnswerFor } from './AnswerFor.js';
+export type { FougereNames } from './FougereNames.js';
+export type { FougerePorts } from './FougerePorts.js';
+export type { NameOf } from './NameOf.js';
+export type { PortChoice } from './PortChoice.js';
+export type { FrondConfig } from './FrondConfig.js';
+export type { OperationOverride } from './OperationOverride.js';
+export { buildGraph, clusterEntities, suggestSplit, type DomainCluster } from './DomainCluster.js';
+export { type EntityNode } from './EntityNode.js';
+export { Crud } from './prefab/CrudConstructor.js';
+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 { Mirror } from './prefab/MirrorConstructor.js';
+export type { MirrorConstructor } from './prefab/MirrorConstructor.js';
+export type { MirrorOf } from './prefab/MirrorOf.js';
+export type { Refreshed } from './prefab/Refreshed.js';
 export { Presenter } from './prefab/presenter.js';
 export type { PresenterViews } from './prefab/presenter.js';
 export { Collector } from './prefab/collector.js';
-export { Repository, type RepositoryOf, type RepositoryConstructor, type AggregateOf, type AggregateConstructor } from './prefab/repository.js';
+export { type AggregateConstructor } from './prefab/AggregateConstructor.js';
+export { type AggregateOf } from './prefab/AggregateOf.js';
+export { Repository, type RepositoryConstructor } from './prefab/RepositoryConstructor.js';
+export { type RepositoryOf } from './prefab/RepositoryOf.js';
 export { Invocation } from './contract.js';
 export type { InvocationContext } from './contract.js';
 export { Call } from './contract.js';
@@ -22,28 +38,30 @@ export { RouteAddress } from './contract.js';
 export { DispatchLifecycle } from './dispatch/DispatchLifecycle.js';
 export { Dispatcher } from './dispatch/Dispatcher.js';
 // The class and not only its type: an observer RECEIVES these, so a package that folds
-// them — or a test of one — has to be able to make one through the door.
+// them — or a test of one — has to be able to make one through the facade.
 export { DispatchEvent } from './dispatch/DispatchEvent.js';
 export type { CallPage, CallRecord } from './contract.js';
 export { driftOf, agrees, explain, type CardDrift } from './contract.js';
-export type {
-  OperationContract,
-  OperationsMap,
-  Param,
-  TypeRef,
-} from './wire/operation.js';
-export { resolveEffectiveOperations } from './effective-operation.js';
-export type { EffectiveOperation } from './effective-operation.js';
+export type { OperationContract } from './wire/OperationContract.js';
+export type { OperationsMap } from './wire/OperationsMap.js';
+export type { Param } from './wire/Param.js';
+export type { TypeRef } from './wire/TypeRef.js';
+export { resolveEffectiveOperations } from './EffectiveOperationModel.js';
+export type { EffectiveOperation } from './EffectiveOperation.js';
 export type { ModuleLoader } from './loader.js';
 export { FougereError, ErrorCode, validationErrorsOf } from './contract.js';
-export type { AppMiddleware, OperationContext, AppNext } from './wire/middleware.js';
+export type { AppMiddleware } from './wire/AppMiddleware.js';
+export type { AppNext } from './wire/AppNext.js';
+export type { OperationContext } from './wire/OperationContext.js';
 export { assertIdentityCard, RPC_ENTITY, MAX_BODY_BYTES } 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
 // is why it sits here and not in `/node`, beside the scanner that reads a project.
-export { frond } from './declare.js';
-export type { Declared, FrondDeclaration, DeclaredSubject } from './declare.js';
+export { frond } from './FrondDeclaration.js';
+export type { Declared } from './Declared.js';
+export type { DeclaredSubject } from './DeclaredSubject.js';
+export type { FrondDeclaration } from './FrondDeclaration.js';
 // What this app would answer to `rpc.discover`. Served by the boot, and reached until now
 // only by tests through a deep path — a consumer comparing its own card to a producer's
 // had to dispatch a call to ask a question about itself.
@@ -51,7 +69,20 @@ export { identityCardOf } from './boot/card.js';
 // Its dual: what the app declares about its NEIGHBOURS. Read by `rpc.topology`, by
 // `@fougere/calls` and by `fougere graph`, which each held their own half of it.
 export { declaredTopologyOf } from './boot/declared.js';
-export type { Facade } from './wire/call.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';
+// 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';
+export type { AnyHandler } from './wire/AnyHandler.js';
+export type { FacadeName } from './wire/FacadeName.js';
+export type { FougereHandlers } from './wire/FougereHandlers.js';
+export type { FougereOperations } from './wire/FougereOperations.js';
+export type { HandlerOf } from './wire/HandlerOf.js';
+export type { Refused } from './wire/Refused.js';
+export type { Rows } from './wire/Rows.js';
+export type { Facade } from './wire/Facade.js';
 export type {
   FrondCall,
   Transport,
@@ -64,48 +95,61 @@ export type {
   DeclaredFrond,
   DeclaredEdge,
 } from './contract.js';
-export { type Emit, type Fact, type Pipe } from './wire/emit.js';
+export { type Emit } from './wire/Emit.js';
+export { type Fact } from './wire/Fact.js';
+export { type Pipe } from './wire/Pipe.js';
 export { callValueOf } from './contract.js';
 export { toHttpError } from './wire/http-error.js';
 export { toPublicError } from './contract.js';
 export { loggerMiddleware } from './wire/loggerMiddleware.js';
-export { Carry, Logger, setLogLevel, logLevel, envLevel, formatted } from './builtin/logger.js';
-export type { LogRecord, Rendered, LogSink } from './builtin/logger.js';
+export { Carry } from './builtin/Carry.js';
+export { Logger, envLevel, formatted, logLevel, setLogLevel } from './builtin/Logger.js';
+export type { LogRecord } from './builtin/LogRecord.js';
+export type { LogSink } from './builtin/LogSink.js';
+export type { Rendered } from './builtin/Rendered.js';
 // The fact a boot announces. Its destinations are `@fougere/log`'s; the line is core's.
 export { default as LogLine, CARRIES_LINE, LOG_LINE } from './builtin/LogLine.js';
 // What a re-read config changes in a running process — and what it cannot.
 export { applyConfig } from './boot/apply.js';
 export { Config } from './builtin/config.js';
-export type { StorageFactory, ListOptions, ListResult, Together } from './storage/port.js';
+export type { ListOptions } from './storage/ListOptions.js';
+export type { ListResult } from './storage/ListResult.js';
+export type { StorageFactory } from './storage/StorageFactory.js';
+export type { Together } from './storage/Together.js';
 // A VALUE as well as a type: it is what a wrapper extends, which is the whole of declaring one.
-export { Storage, togetherKeyOf } from './storage/port.js';
-export type { Constraint, Source, SourceConfig, SourceView } from './source.js';
-export { Sources } from './source.js';
-export { storageOver } from './storage/store.js';
-export type { Store, Values } from './storage/store.js';
-export type { App, CreateAppOptions } from './boot/types.js';
-export type { ScanResult, ScanDiagnostic } from './scan.js';
-export {
-  type Conventions, type ConventionsInput, DEFAULT_CONVENTIONS,
-  resolveConventions, frondPackage, frondDirsOf, providerDirsOf,
-} from './conventions.js';
-export type {
-  FrondDescriptor,
-  FrondSource,
-  ProviderEntry,
-  EntityEntry,
-  HandlerEntry,
-  SeedEntry,
-  PresenterEntry,
-  PresenterFieldMeta,
-  CollectorEntry,
-} from './descriptor/frond.js';
-export type { AuthConfig, AuthContext, AuthRuntime } from './boot/auth.js';
+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 { Sources } from './Source.js';
+export { storageOver } from './storage/Store.js';
+export type { Store } from './storage/Store.js';
+export type { Values } from './storage/Values.js';
+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 { DEFAULT_CONVENTIONS, frondDirsOf, frondPackage, providerDirsOf, resolveConventions, type Conventions } from './Conventions.js';
+export { type ConventionsInput } from './ConventionsInput.js';
+export type { CollectorEntry } from './descriptor/CollectorEntry.js';
+export type { EntityEntry } from './descriptor/EntityEntry.js';
+export type { FrondDescriptor } from './descriptor/FrondDescriptor.js';
+export type { FrondSource } from './descriptor/FrondSource.js';
+export type { HandlerEntry } from './descriptor/HandlerEntry.js';
+export type { PresenterEntry } from './descriptor/PresenterEntry.js';
+export type { PresenterFieldMeta } from './descriptor/PresenterFieldMeta.js';
+export type { ProviderEntry } from './descriptor/ProviderEntry.js';
+export type { SeedEntry } from './descriptor/SeedEntry.js';
+export type { AuthConfig } from './boot/AuthConfig.js';
+export type { AuthContext } from './boot/AuthContext.js';
+export type { AuthRuntime } from './boot/AuthRuntime.js';
 export { Fronds } from './descriptor/Fronds.js';
-export { verify, type Violation } from './verify.js';
+export { verify, type Misplaced } from './verify.js';
 // Same question as verify(), answered from the source text instead of the model.
 // Who is calling, established rather than accepted — the proof beside `state`'s claim.
 // `generateKeyPair` and `issueGrant` are NOT here: they make keys at a deployment and
 // need `node:crypto` for a gesture WebCrypto has no equal of. They sit on `/node`.
-export { signEnvelope, verifyEnvelope, identityFromEnv } from './identity.js';
-export type { FrondIdentity, SignedCall } from './identity.js';
+export { signEnvelope, verifyEnvelope, identityFromEnv } from './CallIdentity.js';
+export type { FrondIdentity } from './FrondIdentity.js';
+export type { SignedCall } from './wire/SignedCall.js';

package/src/node.ts

@@ -1,7 +1,7 @@
 /** What Fougere does with a filesystem, minus the scan — that is `@fougere/compiler`. */
 export { setModuleLoader, getModuleLoader } from './loader.js';
-export { loadConfig, loadCascadedConfig } from './config-loader.js';
-export { defineFrond, loadFrondConfig } from './frond-config.js';
+export { loadConfig, loadCascadedConfig } from './FougereConfig.js';
+export { defineFrond, loadFrondConfig } from './FrondConfig.js';
 
 // Making a key and binding a name to it happen once, at a deployment, on a machine with
 // a filesystem — the CLI speaking. Verifying happens per call, everywhere, and stays on

package/src/prefab/AggregateConstructor.ts

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

package/src/prefab/AggregateOf.ts

@@ -0,0 +1,6 @@
+import { type EntityConstructor } 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[]> =
+  { [K in keyof E]: Storage<InstanceType<E[K]>> };

package/src/prefab/AggregateShape.ts

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