@fougere/core 0.8.4-alpha.0 → 0.9.0-alpha.0

package/src/builtin/logger.ts

@@ -18,6 +18,54 @@ export type LogSink = (record: LogRecord) => void;
 /** Who else takes this process's log lines, beside the console. */
 const sinks: LogSink[] = [];
 
+/**
+ * Where one boot's lines wait, and where they go once they can.
+ *
+ * PER BOOT and never per process: two apps in one process each have their own
+ * destinations, and a slot shared between them sent the second app's lines to the first
+ * app's door — measured on `demos/observability`, where only the first of three printed.
+ *
+ * A boot writes most of what a process ever logs, and it writes it before any emission is
+ * registered, so the lines that say what an app is made of are the ones a destination
+ * would miss. Bounded: a boot that never finishes must not grow, and what is dropped is
+ * the OLDEST since the lines explaining a refusal are the last.
+ */
+export class Carry {
+  private held: LogRecord[] = [];
+  private take?: (line: LogRecord) => void;
+
+  static readonly MAX = 500;
+
+  /** Take it now, or keep it for whoever arrives. */
+  push(record: LogRecord): void {
+    if (this.take) {
+      try {
+        this.take(record);
+      } catch { /* announcing never breaks logging, for the same reason a sink does not */ }
+      return;
+    }
+    this.held.push(record);
+    if (this.held.length > Carry.MAX) this.held.shift();
+  }
+
+  /** Hand what is held over, and everything after it. */
+  to(take: (line: LogRecord) => void): () => void {
+    this.take = take;
+    for (const line of this.held.splice(0)) take(line);
+
+    return () => { this.take = undefined; };
+  }
+
+  /**
+   * Forget what is still held — a boot that refused, or an app that declares no
+   * destination. Nothing is printed: the console had every one of these lines when it was
+   * written, and the hold exists only to hand them on later.
+   */
+  forget(): void {
+    this.held.length = 0;
+  }
+}
+
 /** Take every line this process logs. Returns the way to withdraw. */
 export function onLog(next: LogSink): () => void {
   sinks.push(next);
@@ -79,8 +127,8 @@ function supportsColor(): boolean {
   return false;
 }
 
-function formatTime(): string {
-  const d = new Date();
+function stamp(at: number | Date): string {
+  const d = new Date(at);
   const h = String(d.getHours()).padStart(2, '0');
   const m = String(d.getMinutes()).padStart(2, '0');
   const s = String(d.getSeconds()).padStart(2, '0');
@@ -91,6 +139,12 @@ function formatTime(): string {
 export interface LoggerOptions {
   /** Logger name / prefix. */
   name?: string;
+  /**
+   * Where its lines go — one boot's, so two apps in a process do not share a door. A
+   * logger without one writes to the console and nowhere else, which is what the boot's
+   * first lines do and what an app declaring no destination does forever.
+   */
+  carry?: Carry;
   /** Force color on/off. Auto-detected by default. */
   color?: boolean;
 }
@@ -98,15 +152,17 @@ export interface LoggerOptions {
 export class Logger {
   private name: string;
   private color: boolean;
+  private carry?: Carry;
 
   constructor(prefix?: string, options?: Omit<LoggerOptions, 'name'>) {
     this.name = prefix ?? 'app';
     this.color = options?.color ?? supportsColor();
+    this.carry = options?.carry;
   }
 
   /** Create a child logger with a sub-name. It carries no level of its own either. */
   child(name: string): Logger {
-    return new Logger(`${this.name}:${name}`, { color: this.color });
+    return new Logger(`${this.name}:${name}`, { color: this.color, ...(this.carry ? { carry: this.carry } : {}) });
   }
 
   debug(msg: string, ...args: unknown[]) { this.log('debug', msg, args); }
@@ -116,27 +172,63 @@ export class Logger {
 
   private log(level: string, msg: string, args: unknown[]) {
     if (LEVELS[level as LogLevel] < threshold) return;
+    const record: LogRecord = {
+      level: level as LogRecord['level'], name: this.name, message: msg, args, at: Date.now(),
+    };
 
     // Beside the console, never instead of it: a forwarded line is an addition, and a
     // sink that throws must not cost the operator the line they were reading.
     for (const take of sinks) {
       try {
-        take({ level: level as LogRecord['level'], name: this.name, message: msg, args, at: Date.now() });
+        take(record);
       } catch { /* forwarding never breaks logging */ }
     }
 
-    const style = LEVEL_STYLE[level];
-    const time = formatTime();
-    // One console method per level. `debug` and `info` both went to `console.log`, so
-    // nothing downstream — a terminal filter, a collector — could tell them apart.
-    const method = level as 'debug' | 'info' | 'warn' | 'error';
-
-    if (this.color) {
-      const c = COLORS[style.color];
-      const prefix = `${COLORS.dim}${time}${COLORS.reset} ${c}${COLORS.bold}${style.badge}${COLORS.reset} ${COLORS.magenta}${this.name}${COLORS.reset}`;
-      console[method](prefix, msg, ...args);
-    } else {
-      console[method](`${time} ${style.badge} [${this.name}]`, msg, ...args);
-    }
+    this.carry?.push(record);
+
+    // The console ALWAYS, whoever else took the line. Skipping it once a destination
+    // existed made `calls()` — a devtools ring that prints nothing — silence the
+    // operator's terminal: 306 per-operation lines in `demos/observability` became 2.
+    // A destination sends a line ELSEWHERE; it does not take over stderr.
+    const { method, text } = formatted(record, this.color);
+    console[method](...text);
   }
 }
+
+/**
+ * One line, ready for a terminal — the console arguments and which method takes them.
+ *
+ * Here rather than inside the class because the boot is not the only writer: a destination
+ * that prints (`@fougere/log`) hands its own record to the same formatting, so the two
+ * outputs cannot drift.
+ *
+ * One console method per level: `debug` and `info` both went to `console.log`, so nothing
+ * downstream — a terminal filter, a collector — could tell them apart.
+ */
+export interface Rendered {
+  level: Exclude<LogLevel, 'silent'>;
+  name: string;
+  message: string;
+  /** Absent on most lines: a message usually carries its own detail. */
+  args?: unknown[] | null;
+  /** Epoch milliseconds from a logger, a `Date` from an entity that stamped it. */
+  at: number | Date;
+}
+
+export function formatted(
+  record: Rendered,
+  color = supportsColor(),
+): { method: Rendered['level']; text: unknown[] } {
+  const style = LEVEL_STYLE[record.level];
+  const time = stamp(record.at);
+  const method = record.level;
+
+  if (color) {
+    const c = COLORS[style.color];
+    const prefix = `${COLORS.dim}${time}${COLORS.reset} ${c}${COLORS.bold}${style.badge}${COLORS.reset} ${COLORS.magenta}${record.name}${COLORS.reset}`;
+
+    return { method, text: [prefix, record.message, ...(record.args ?? [])] };
+  }
+
+  return { method, text: [`${time} ${style.badge} [${record.name}]`, record.message, ...(record.args ?? [])] };
+}

package/src/config-loader.ts

@@ -22,7 +22,8 @@ export interface FougereConfig {
   /** Remote fronds — frondName → base URL. */
   remotes?: Record<string, string>;
   /** Which realization answers which port — port class name → implementation class name. */
-  ports?: Record<string, string>;
+  /** What answers a port — a name, or the chain from the outside in. */
+  ports?: Record<string, string | readonly string[]>;
   /** Auth declaration — picks a provider package and forwards options to it. */
   auth?: AuthConfig;
   /** Which protocol adapters this app serves. */

package/src/contract.ts

@@ -3,25 +3,21 @@
  * runtime: the error vocabulary, the invocation shape, the call value, the naming convention.
  */
 import { lowerFirst } from '@fougere/schema';
-import { canonicalInvocation, type InvocationContext } from './wire/Invocation.js';
+import { Invocation, type InvocationContext } from './wire/Invocation.js';
 import type { FrondCall } from './wire/call.js';
 
 export { FougereError, ErrorCode, validationErrorsOf } from './wire/errors.js';
 // What a read may ask about one field. Here rather than on the main entry because an
 // adapter reads it to compile a query, and an adapter carries no boot.
-export { comparisonOf, comparisonsIn, unknownIn, COMPARISONS } from './storage/criterion.js';
-export type { Comparison, ComparisonName } from './storage/criterion.js';
+export { comparisonOf, comparisonsIn } from './storage/criterion.js';
+export type { Comparison } from './storage/criterion.js';
 // A receiver turns a refusal into what may cross a process boundary, and it is not
 // core's boot — reaching it through the main entry dragged the scanner into a bundle.
 export { toPublicError } from './wire/http-error.js';
-export type { FougereErrorOptions } from './wire/errors.js';
-export { canonicalInvocation, EMPTY_INVOCATION } from './wire/Invocation.js';
-export type { InvocationContext } from './wire/Invocation.js';
 export { Invocation } from './wire/Invocation.js';
-export type { PartialInvocation } from './wire/Invocation.js';
+export type { InvocationContext } from './wire/Invocation.js';
 export { Call } from './wire/call.js';
 export { RouteAddress } from './wire/RouteAddress.js';
-export type { RouteAddressInput } from './wire/RouteAddress.js';
 export type { FrondCall, Transport, SignedCall } from './wire/call.js';
 export { MAX_BODY_BYTES } from './wire/call.js';
 // The reserved entity, VALUE and not type: a consumer that wants to leave it alone — a
@@ -59,5 +55,5 @@ export function callValueOf(
     typeof opOrInput === 'string'
       ? [{ entity: lowerFirst((target as { name: string }).name), op: opOrInput }, input]
       : [target as FrondCall, opOrInput];
-  return { call, invocation: canonicalInvocation(given) };
+  return { call, invocation: Invocation.from(given) };
 }

package/src/conventions.ts

@@ -14,6 +14,12 @@ export interface Conventions {
     presenters: string;
     collectors: string;
     seeds: string;
+    /**
+     * What runs around this frond's operations. Scoped to the frond that declares it,
+     * unless `frond.config.ts` widens it — the one directory whose members apply to code
+     * they do not name.
+     */
+    middlewares: string;
     /**
      * What the domain computes with nothing injected. Read into the type program, because
      * a handler names one of its types in a signature, and registered nowhere: no class
@@ -37,6 +43,7 @@ export const DEFAULT_CONVENTIONS: Conventions = {
     presenters: 'presenters',
     collectors: 'collectors',
     seeds: 'seeds',
+    middlewares: 'middlewares',
     rules: 'rules',
     versions: 'versions',
   },
@@ -70,9 +77,9 @@ export function providerDirsOf(conventions: Conventions): string[] {
 
 /** The frond vocabulary — every directory the scan reads. */
 export function frondDirsOf(conventions: Conventions): string[] {
-  const { entities, handlers, presenters, collectors, seeds, rules, versions } = conventions.dirs;
+  const { entities, handlers, presenters, collectors, seeds, middlewares, rules, versions } = conventions.dirs;
   return [...new Set([
-    entities, handlers, presenters, collectors, seeds, rules, versions,
+    entities, handlers, presenters, collectors, seeds, middlewares, rules, versions,
     ...providerDirsOf(conventions),
   ])];
 }

package/src/declare.ts

@@ -1,7 +1,7 @@
 /** A frond stated by its author, for an app that will not scan. */
 import { lowerFirst, type SchemaView } from '@fougere/schema';
 import type {
-  CollectorEntry, EntityEntry, FrondDescriptor, HandlerEntry,
+  CollectorEntry, EntityEntry, FrondDescriptor, HandlerEntry, MiddlewareEntry,
   PresenterEntry, ProviderEntry, SeedEntry,
 } from './descriptor/frond.js';
 import { DEFAULT_CONVENTIONS } from './conventions.js';
@@ -90,6 +90,14 @@ export interface FrondDeclaration {
   collectors?: (Ctor | DeclaredSubject)[];
   providers?: Declared[];
   seeds?: { entityName: string; data: SeedEntry['data'] }[];
+  /**
+   * What runs around this frond's operations. The scope is stated beside the class here,
+   * where `frond.config.ts` states it by class name — a statement has no config file to
+   * put it in.
+   */
+  middlewares?: (Ctor | (DeclaredSubject & { scope?: MiddlewareEntry['scope'] }))[];
+  /** The ops that finish a fact, in order — the same key `frond.config.ts` states. */
+  pipes?: Record<string, string[]>;
   /** Per-surface entity lists — the same key `frond.config.ts` states. */
   surfaces?: Record<string, string[]>;
   /** The import scope this frond answers under. Defaults to the conventional one. */
@@ -179,6 +187,14 @@ export function frond(name: string, declared: FrondDeclaration = {}): FrondDescr
     filePath: '',
   }));
 
+  const middlewares: MiddlewareEntry[] = (declared.middlewares ?? []).map((m) => ({
+    name: ctorOf(m).name,
+    ctor: ctorOf(m),
+    scope: (typeof m === 'function' ? undefined : m.scope) ?? 'frond',
+    deps: depsOf(m),
+    filePath: '',
+  }));
+
   return {
     name,
     source: { path: '', package: `${scope}/${name}` },
@@ -189,6 +205,8 @@ export function frond(name: string, declared: FrondDeclaration = {}): FrondDescr
     presenters,
     collectors,
     seeds,
+    middlewares,
+    ...(declared.pipes ? { pipes: declared.pipes } : {}),
     ...(declared.surfaces ? { surfaces: declared.surfaces } : {}),
   };
 }

package/src/descriptor/frond.ts

@@ -112,6 +112,23 @@ export interface CollectorEntry {
   filePath: string;
 }
 
+/**
+ * A discovered middleware — a class declaring `around(ctx, next)`, which runs before and
+ * after every operation in its scope.
+ */
+export interface MiddlewareEntry {
+  /** Class name — what `frond.config.ts` addresses to widen the scope. */
+  name: string;
+  /** The middleware class. */
+  ctor: new (...args: never[]) => unknown;
+  /** How far it reaches: its own frond's entities, or every operation in the process. */
+  scope: 'frond' | 'app';
+  /** Constructor dependency type names (from AST scan). */
+  deps: string[];
+  /** Absolute file path (for debugging). */
+  filePath: string;
+}
+
 /** A discovered seed file (array of records or async factory). */
 export interface SeedEntry {
   /** Entity name this seed targets (from filename: Author.seed.ts → 'author'). */
@@ -142,6 +159,16 @@ export interface FrondDescriptor {
   presenters: PresenterEntry[];
   collectors: CollectorEntry[];
   seeds: SeedEntry[];
+  middlewares: MiddlewareEntry[];
+  /**
+   * Brought by an EXTENSION rather than by the app — `@fougere/calls` keeping its lines,
+   * `@fougere/observability` sending them on. It is installed like any other, and it is not
+   * what the app SERVES: a report that lists it describes the instrumentation, not the
+   * domain. Set by the boot, never by a declaration.
+   */
+  brought?: true;
+  /** 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'] }).
@@ -156,5 +183,9 @@ export interface FrondDescriptor {
     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/index.ts

@@ -8,7 +8,7 @@ export { Fronds } from './Fronds.js';
 export { cardinalityOf, type OperationContract, type OperationsMap, type Param, type TypeRef } from '../wire/operation.js';
 export { computeBindingPlan, type BindingPlan } from '../wire/binding.js';
 export type { Signature } from '../wire/signature.js';
-export { emitKeyOf } from '../wire/emit.js';
+export { emitKeyOf, awaitKeyOf } from '../wire/emit.js';
 export { storageKeyOf } from '../storage/port.js';
 export { getPresenterFields } from '../prefab/presenter.js';
 export { targetOf, viewsOf, outputOf } from '../prefab/prefab.js';

package/src/dispatch/ArgumentResolver.ts

@@ -38,8 +38,12 @@ export class ArgumentResolver {
           args.push(val);
           break;
         }
-        case 'fact': {
-          // A fact IS the payload — the whole of what happened, never a piece of it.
+        case 'fact':
+        case 'pipe': {
+          // A fact IS the payload — the whole of what happened, never a piece of it. The
+          // same holds before it is final: an op that finishes one is handed all of it,
+          // and answers all of it.
+          //
           // Identical to `input` today, and deliberately not sharing its branch: the two
           // agree by coincidence, not by rule, and the day `input` learns to look up a
           // value by parameter name a subscriber would receive ONE FIELD of the fact it

package/src/dispatch/HandlerFacade.ts

@@ -13,7 +13,7 @@ import { repositoryKeyOf } from '../prefab/repository.js';
 import type { OperationContract, OperationsMap } from '../wire/operation.js';
 import type { EffectiveOperation, EffectiveOperationsMap } from '../effective-operation.js';
 import type { BindingPlan } from '../wire/binding.js';
-import { canonicalInvocation, type InvocationContext } from '../wire/Invocation.js';
+import { Invocation, type InvocationContext } from '../wire/Invocation.js';
 import type { HandlerEntry, PresenterEntry } from '../descriptor/frond.js';
 import { ArgumentResolver } from './ArgumentResolver.js';
 import { OutputView } from './OutputView.js';
@@ -101,7 +101,7 @@ export class HandlerFacade {
       );
     }
 
-    const invocation = canonicalInvocation(input);
+    const invocation = Invocation.from(input);
     const context: OperationContext = {
       entity,
       frond: this.door.frond,

package/src/effective-operation.ts

@@ -229,13 +229,19 @@ export function resolveEffectiveOperations(
 
         // A fact is validated by the entity it names. This used to be patched into the
         // facade after resolution, leaving check/explain with a different input.
-        let input = contract.input;
-        if (!input) {
-          const fact = contract.binding.find((binding) => binding.source.kind === 'fact');
-          if (fact?.source.kind === 'fact') input = schemas.get(fact.source.factName);
-        }
-
-        const output = effectiveOutput(frond, handler, name, contract);
+        const announced = contract.binding.find((binding) =>
+          binding.source.kind === 'fact' || binding.source.kind === 'pipe');
+        const fact = announced?.source.kind === 'fact' || announced?.source.kind === 'pipe'
+          ? schemas.get(announced.source.factName)
+          : undefined;
+        const input = contract.input ?? fact;
+
+        // An op that FINISHES a fact answers the fact, so its answer is the fact's shape:
+        // derived here, where its input already is. Left to the ordinary projection it
+        // came back stripped — measured, the subscriber got a value with no `id`.
+        const output = announced?.source.kind === 'pipe' && fact
+          ? { schema: fact, closed: false }
+          : effectiveOutput(frond, handler, name, contract);
         const className = handler.ctor.name.endsWith('Handler')
           ? handler.ctor.name.slice(0, -'Handler'.length)
           : handler.ctor.name;

package/src/frond-config.ts

@@ -11,6 +11,12 @@ export interface OperationOverride {
   kind?: 'query' | 'command';
   /** The GraphQL root field this op answers to. */
   graphql?: string;
+  /**
+   * Where this op answers over REST — the dual of `graphql:`, and the frond's to say for
+   * the same reason: how an operation is CALLED belongs beside it, not in whatever host
+   * mounts the router. The prefix stays the host's: naming is the frond's, mounting is not.
+   */
+  rest?: { method?: string; path?: string; status?: number };
   /**
    * Handler class to delegate to (overrides the default `{Entity}Handler` lookup).
    * Class name is used to resolve from DI. E.g. `ArchiveHandler` → `app.resolve('ArchiveHandler')`.
@@ -44,6 +50,20 @@ export interface FrondConfig {
   surfaces?: Record<string, string[]>;
   /** Interface → implementation bindings for DI (e.g. { Database: 'SqliteDatabase' }). */
   bindings?: Record<string, string>;
+  /**
+   * The ops that FINISH a fact, in the order they run — by class name, keyed by fact.
+   *
+   * Declared by the frond that OWNS the fact, because ordering is a decision about the
+   * fact itself and it has one owner. Without it two links refuse: nothing would say which
+   * ran first, and scan order is not an answer.
+   */
+  pipes?: Record<string, string[]>;
+  /**
+   * How far a middleware reaches, by class name. A middleware answers for its own frond
+   * without being named here; `'app'` is the exception, and it is stated by the frond
+   * that decides for the others.
+   */
+  middlewares?: Record<string, 'frond' | 'app'>;
   /** Per-operation overrides. Key = operation name (method name on a handler). */
   operations?: Record<string, OperationOverride>;
 }

package/src/index.ts

@@ -4,87 +4,74 @@ export { orderSeeds, runSeeds, seeding } from './boot/seed.js';
 export { AppLifecycle, migrating } from './boot/AppLifecycle.js';
 export type { Extension } from './boot/AppLifecycle.js';
 export { defineFougere } from './define.js';
-export type { AdapterConfig, FougereConfig } from './config-loader.js';
-export type { FrondConfig, OperationOverride } from './frond-config.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 { CrudOps, CrudOpName, CrudViews, CrudConstructor } from './prefab/crud.js';
+export type { CrudViews, CrudOps, CrudOpName, CrudConstructor } from './prefab/crud.js';
 export { Mirror } from './prefab/mirror.js';
-export type { MirrorOf, MirrorConstructor, Refreshed } from './prefab/mirror.js';
+export type { Refreshed, MirrorOf, MirrorConstructor } from './prefab/mirror.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 { Invocation, canonicalInvocation, EMPTY_INVOCATION } from './wire/Invocation.js';
-export type { InvocationContext, PartialInvocation } from './wire/Invocation.js';
-export { Call } from './wire/call.js';
-export { RouteAddress } from './wire/RouteAddress.js';
-export type { RouteAddressInput } from './wire/RouteAddress.js';
+export { Invocation } from './contract.js';
+export type { InvocationContext } from './contract.js';
+export { Call } from './contract.js';
+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.
 export { DispatchEvent } from './dispatch/DispatchEvent.js';
-export type { CallPage, CallRecord } from './wire/CallLog.js';
-export { driftOf, agrees, explain, type CardDrift } from './wire/drift.js';
-export type { DispatchObserver } from './dispatch/DispatchEvent.js';
-export type { DispatchPort } from './dispatch/DispatchPort.js';
-export {
-  inferOperationKind,
-  resolveIsReadOp,
-  resolveOperationKind,
-} from './wire/operation.js';
-export { resolveContracts } from './effective-operation.js';
+export type { CallPage, CallRecord } from './contract.js';
+export { driftOf, agrees, explain, type CardDrift } from './contract.js';
 export type {
   OperationContract,
-  OperationKind,
-  OperationKindInference,
   OperationsMap,
   Param,
   TypeRef,
 } from './wire/operation.js';
-export {
-  EFFECTIVE_OPERATION_SEMANTICS,
-  EffectiveOperationModel,
-  resolveEffectiveOperations,
-} from './effective-operation.js';
-export type {
-  EffectiveCollector,
-  EffectiveOperation,
-  EffectiveOperationOptions,
-  EffectiveOperationsMap,
-  EffectiveParameter,
-} from './effective-operation.js';
+export { resolveEffectiveOperations } from './effective-operation.js';
+export type { EffectiveOperation } from './effective-operation.js';
 export type { ModuleLoader } from './loader.js';
-export { FougereError, ErrorCode, validationErrorsOf, type FougereErrorOptions } from './wire/errors.js';
-export type { OperationContext, AppNext, AppMiddleware } from './wire/middleware.js';
-export { assertIdentityCard, RPC_ENTITY, MAX_BODY_BYTES } from './wire/call.js';
+export { FougereError, ErrorCode, validationErrorsOf } from './contract.js';
+export type { AppMiddleware, OperationContext, AppNext } from './wire/middleware.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 { FrondDeclaration, Declared, DeclaredSubject } from './declare.js';
+export type { Declared, FrondDeclaration, DeclaredSubject } from './declare.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.
 export { identityCardOf } from './boot/card.js';
+export type { Facade } from './wire/call.js';
 export type {
-  FrondCall, Transport, IdentityCard, CardOp, Facade, RpcAnswer,
-  TopologyReport, FrondPlacement, Edge,
-} from './wire/call.js';
-export { type Emit, type Fact } from './wire/emit.js';
+  FrondCall,
+  Transport,
+  IdentityCard,
+  CardOp,
+  TopologyReport,
+  FrondPlacement,
+  Edge,
+} from './contract.js';
+export { type Emit, type Fact, type Pipe } from './wire/emit.js';
 export { callValueOf } from './contract.js';
-export type { CallValue } from './contract.js';
-export { toHttpError, toPublicError } from './wire/http-error.js';
+export { toHttpError } from './wire/http-error.js';
+export { toPublicError } from './contract.js';
 export { loggerMiddleware } from './wire/loggerMiddleware.js';
-export { Logger, setLogLevel, logLevel, envLevel, onLog } from './builtin/logger.js';
-export type { LogLevel, LogRecord, LogSink } from './builtin/logger.js';
+export { Carry, Logger, setLogLevel, logLevel, envLevel, onLog, formatted } from './builtin/logger.js';
+export type { LogRecord, Rendered, LogSink } from './builtin/logger.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, type ConfigApplication } from './boot/apply.js';
+export { applyConfig } from './boot/apply.js';
 export { Config } from './builtin/config.js';
 export type { Storage, StorageFactory, ListOptions, ListResult, Together } from './storage/port.js';
-export { togetherKeyOf, membersOfTogetherKey } from './storage/port.js';
+export { 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';
@@ -102,17 +89,16 @@ export type {
   EntityEntry,
   HandlerEntry,
   SeedEntry,
-  SeedFactory,
   PresenterEntry,
   PresenterFieldMeta,
   CollectorEntry,
 } from './descriptor/frond.js';
 export type { AuthConfig, AuthContext, AuthRuntime } from './boot/auth.js';
 export { Fronds } from './descriptor/Fronds.js';
-export { verify, assertSplittable, type Violation } from './verify.js';
+export { verify, type Violation } 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, VerifiedCall, CallIdentity, SignedCall } from './identity.js';
+export type { FrondIdentity, SignedCall } from './identity.js';

package/src/wire/Invocation.ts

@@ -60,6 +60,8 @@ export class Invocation implements InvocationContext {
     return context instanceof Invocation ? context : new Invocation(context ?? {});
   }
 
+  static readonly empty = Invocation.from();
+
   /** Replaces the input — how the façade hands on the value it parsed. */
   withInput(input: unknown): Invocation {
     return new Invocation({ ...this, input });
@@ -70,10 +72,3 @@ export class Invocation implements InvocationContext {
     return new Invocation({ ...this, state });
   }
 }
-
-export const EMPTY_INVOCATION = Invocation.from();
-
-/** Names the same gesture as `Invocation.from` for callers that read better this way. */
-export function canonicalInvocation(context?: PartialInvocation): Invocation {
-  return Invocation.from(context);
-}