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

package/src/wire/{errors.ts → FougereError.ts}

@@ -1,63 +1,24 @@
+import type { ValidationError } from '@fougere/schema';
+import { ErrorCode } from './ErrorCode.js';
+import type { FougereErrorOptions } from './FougereErrorOptions.js';
+
 /**
- * The error vocabulary — what a refusal IS, independently of who hears it.
+ * A refusal, and which one — narrowed by the operation that answered it where the caller knows.
  *
- * Documented: [errors](https://fougere.dev/docs/business/errors).
+ * `Code` defaults to every code there is, so a thrower writes what it always wrote. What it buys
+ * is on the READING side: a client generated from a card gets `FougereError<'NOT_FOUND' |
+ * 'CONFLICT'>`, and a `switch` over `code` with a `never` in its default stops compiling the day
+ * the op learns to refuse something else.
+ *
+ * Documented: [observability](https://fougere.dev/docs/infra/observability).
  */
-
-import type { ValidationError } from '@fougere/schema';
-
-// ── ErrorCode ──────────────────────────────────
-
-/** Semantic error codes — transport-agnostic. Each bridge maps them to its own format. */
-export enum ErrorCode {
-  // Input
-  VALIDATION_FAILED = 'VALIDATION_FAILED',
-  BAD_REQUEST = 'BAD_REQUEST',
-
-  // Auth
-  UNAUTHORIZED = 'UNAUTHORIZED',
-  FORBIDDEN = 'FORBIDDEN',
-
-  // Resources
-  NOT_FOUND = 'NOT_FOUND',
-  GONE = 'GONE',
-  CONFLICT = 'CONFLICT',
-  LOCKED = 'LOCKED',
-  METHOD_NOT_ALLOWED = 'METHOD_NOT_ALLOWED',
-
-  // Limits
-  PRECONDITION_FAILED = 'PRECONDITION_FAILED',
-  PAYLOAD_TOO_LARGE = 'PAYLOAD_TOO_LARGE',
-  UNPROCESSABLE_ENTITY = 'UNPROCESSABLE_ENTITY',
-  TOO_MANY_REQUESTS = 'TOO_MANY_REQUESTS',
-  REQUEST_TIMEOUT = 'REQUEST_TIMEOUT',
-
-  // Server
-  INTERNAL_ERROR = 'INTERNAL_ERROR',
-  NOT_IMPLEMENTED = 'NOT_IMPLEMENTED',
-  BAD_GATEWAY = 'BAD_GATEWAY',
-  SERVICE_UNAVAILABLE = 'SERVICE_UNAVAILABLE',
-  GATEWAY_TIMEOUT = 'GATEWAY_TIMEOUT',
-}
-
-// ── FougereError ────────────────────────────────
-
-export interface FougereErrorOptions {
-  code: ErrorCode;
-  message: string;
-  entity?: string;
-  operation?: string;
-  details?: unknown;
-  cause?: unknown;
-}
-
-export class FougereError extends Error {
-  readonly code: ErrorCode;
+export class FougereError<Code extends ErrorCode = ErrorCode> extends Error {
+  readonly code: Code;
   readonly entity?: string;
   readonly operation?: string;
   readonly details?: unknown;
 
-  constructor(options: FougereErrorOptions) {
+  constructor(options: FougereErrorOptions<Code>) {
     super(options.message, { cause: options.cause });
     this.name = new.target.name;
     this.code = options.code;

package/src/wire/FougereErrorOptions.ts

@@ -0,0 +1,10 @@
+import type { ErrorCode } from './ErrorCode.js';
+
+export interface FougereErrorOptions<Code extends ErrorCode = ErrorCode> {
+  code: Code;
+  message: string;
+  entity?: string;
+  operation?: string;
+  details?: unknown;
+  cause?: unknown;
+}

package/src/wire/FougereHandlers.ts

@@ -0,0 +1,8 @@
+/**
+ * The handler behind each address, carried as `import('…/PostHandler').default`.
+ *
+ * TypeScript resolves it from the source, so the operations that exist and what each one
+ * answers cost the generated module nothing: no signature is printed into it, and none can
+ * drift from the class it was read off.
+ */
+export interface FougereHandlers {}

package/src/wire/FougereOperations.ts

@@ -0,0 +1,2 @@
+/** What one facade answers for, keyed `address.op` — `surface:address.op` for a named surface. */
+export interface FougereOperations {}

package/src/wire/FrondCall.ts

@@ -0,0 +1,9 @@
+/** Target of a call — which façade operation, wherever it lives. */
+export interface FrondCall {
+  /** Frond name, when the caller knows it. Routing hint only. */
+  frond?: string;
+  /** Entity registration key (e.g. 'product'). */
+  entity: string;
+  /** Façade operation name (e.g. 'findById', 'search'). */
+  op: string;
+}

package/src/wire/HandlerOf.ts

@@ -0,0 +1,10 @@
+import type { FougereHandlers } from './FougereHandlers.js';
+import type { AnyHandler } from './AnyHandler.js';
+
+/**
+ * The handler that answers at one address. It falls back to an unconstrained facade when nothing
+ * was generated, because a `never` there would refuse every call a project makes.
+ */
+export type HandlerOf<Address extends string> =
+  [keyof FougereHandlers] extends [never] ? AnyHandler
+  : Address extends keyof FougereHandlers ? FougereHandlers[Address] : AnyHandler;

package/src/wire/Invocation.ts

@@ -1,14 +1,5 @@
-export interface InvocationContext {
-  params: Record<string, unknown>;
-  query: Record<string, unknown>;
-  input: unknown;
-  state: Record<string, unknown>;
-  trace?: string;
-  identity?: string;
-  caller?: string;
-}
-
-export type PartialInvocation = Partial<InvocationContext>;
+import type { InvocationContext } from './InvocationContext.js';
+import type { PartialInvocation } from './PartialInvocation.js';
 
 /** Freezes plain data deeply, and leaves a class instance alone — a `Date` is not a record. */
 function canonicalValue(value: unknown): unknown {

package/src/wire/InvocationContext.ts

@@ -0,0 +1,9 @@
+export interface InvocationContext {
+  params: Record<string, unknown>;
+  query: Record<string, unknown>;
+  input: unknown;
+  state: Record<string, unknown>;
+  trace?: string;
+  identity?: string;
+  caller?: string;
+}

package/src/wire/OperationContext.ts

@@ -0,0 +1,18 @@
+// ── Types ───────────────────────────────────────
+export interface OperationContext {
+  /** Entity name (e.g. 'product'). */
+  entity: string;
+  /**
+   * Which frond owns this operation — the unit that gets deployed, and therefore the
+   * one a reader groups by first. Absent only where no frond claims the call.
+   */
+  frond?: string;
+  /** Operation name (e.g. 'create', 'findById', 'searchByTitle'). */
+  operation: string;
+  /** Arguments passed to the operation. */
+  args: unknown[];
+  /** Extensible bag — middlewares deposit data here (user, permissions, etc.). */
+  state: Record<string, unknown>;
+  /** Transport-agnostic invocation context (params, query, input, state). */
+  invocation?: import('./InvocationContext.js').InvocationContext;
+}

package/src/wire/{operation.ts → OperationContract.ts}

@@ -1,6 +1,10 @@
 import type { SchemaView } from '@fougere/schema';
 import type { BindingPlan } from './binding.js';
-import type { Signature, TypeRef, Param } from './signature.js';
+import type { Signature } from './Signature.js';
+import type { TypeRef } from './TypeRef.js';
+import type { ErrorCode } from './ErrorCode.js';
+import type { OperationKind } from './OperationKind.js';
+import type { OperationKindInference } from './OperationKindInference.js';
 
 /** The contract of one operation — everything the façade needs to serve a call. */
 export interface OperationContract {
@@ -16,6 +20,15 @@ export interface OperationContract {
   cardinality?: 'one' | 'maybe' | 'many' | 'page' | 'none';
   /** The argument names and TYPES — the one thing `binding` cannot say. */
   signature?: Signature;
+  /**
+   * The refusals a path from this operation can reach, walked from every `throw` upward.
+   *
+   * What the FRAMEWORK refuses is not here: `VALIDATION_FAILED` follows from `input`,
+   * `SERVICE_UNAVAILABLE` from being dispatched at all, the gateway pair from a remote
+   * placement — all already on the card, so listing them per op would write one fact twice.
+   * `refusalsOf` puts the two halves together for whoever reads.
+   */
+  errors?: ErrorCode[];
 }
 
 /** Read an op's cardinality off its parsed return type. */
@@ -32,26 +45,6 @@ export function cardinalityOf(type: TypeRef | undefined): OperationContract['car
 /** A return that carries no schema — the card has nothing to project onto it. */
 const PRIMITIVE_RETURNS = new Set(['boolean', 'string', 'number', 'void', 'undefined', 'unknown', 'any']);
 
-/** Map of operation name → its contract. */
-export type OperationsMap = Map<string, OperationContract>;
-
-export type { TypeRef, Param };
-
-// ─── Operation intent (read vs write) ──────────
-// Naming convention for inferred handlers — scheduled to die with the
-// handler-kind plan (docs/notes/handler-kind.md). Lives here, NOT in
-// @fougere/schema: it is a runtime convention about operations, not a
-// schema concept.
-
-export type OperationKind = 'query' | 'command';
-
-/** The convention's evidence, including both sides when a composed name contradicts itself. */
-export interface OperationKindInference {
-  kind?: OperationKind;
-  queryMatches: string[];
-  commandMatches: string[];
-}
-
 /** Deliberately finite. */
 const QUERY_VERBS = new Set([
   'all', 'check', 'count', 'exists', 'fetch', 'find', 'get', 'has', 'health', 'list',
@@ -157,5 +150,3 @@ function requireOperationKind(
     + `Declare operations.${name}.kind as 'query' or 'command' in frond.config.ts.`,
   );
 }
-
-

package/src/wire/OperationKind.ts

@@ -0,0 +1 @@
+export type OperationKind = 'query' | 'command';

package/src/wire/OperationKindInference.ts

@@ -0,0 +1,8 @@
+import type { OperationKind } from './OperationKind.js';
+
+/** The convention's evidence, including both sides when a composed name contradicts itself. */
+export interface OperationKindInference {
+  kind?: OperationKind;
+  queryMatches: string[];
+  commandMatches: string[];
+}

package/src/wire/OperationsMap.ts

@@ -0,0 +1,14 @@
+import type { Param } from './Param.js';
+import type { TypeRef } from './TypeRef.js';
+import type { OperationContract } from './OperationContract.js';
+
+/** Map of operation name → its contract. */
+export type OperationsMap = Map<string, OperationContract>;
+
+export type { TypeRef, Param };
+
+// ─── Operation intent (read vs write) ──────────
+// Naming convention for inferred handlers — scheduled to die with the
+// handler-kind plan (docs/notes/handler-kind.md). Lives here, NOT in
+// @fougere/schema: it is a runtime convention about operations, not a
+// schema concept.

package/src/wire/Param.ts

@@ -0,0 +1,8 @@
+import type { TypeRef } from './TypeRef.js';
+
+/** One parameter of a signature. */
+export interface Param {
+  name: string;
+  type: TypeRef;
+  optional?: boolean;
+}

package/src/wire/PartialInvocation.ts

@@ -0,0 +1,3 @@
+import type { InvocationContext } from './InvocationContext.js';
+
+export type PartialInvocation = Partial<InvocationContext>;

package/src/wire/Pipe.ts

@@ -0,0 +1,9 @@
+/**
+ * The same fact, BEFORE it is final: an op taking one ANSWERS the value every subscriber
+ * then receives, so it is the declared form of what `Emissions.stamped` already does for
+ * `created()`.
+ *
+ * Not a second announcement and not a chain a subscriber joins: the links run once, before
+ * anyone is handed anything, which is what keeps a fact the same for every reader.
+ */
+export type Pipe<T> = T;

package/src/wire/Refused.ts

@@ -0,0 +1,13 @@
+import type { ErrorCode } from './ErrorCode.js';
+import type { FougereOperations } from './FougereOperations.js';
+
+/**
+ * What one call can come back refusing — both halves, the frond's and the framework's, as the
+ * generated module already merged them. Every code until a scan has narrowed it.
+ */
+export type Refused<Address extends string, Op extends string> =
+  `${Address}.${Op}` extends keyof FougereOperations
+    ? FougereOperations[`${Address}.${Op}`] extends { errors: infer Codes }
+      ? [Codes] extends [ErrorCode] ? Codes : ErrorCode
+      : ErrorCode
+    : ErrorCode;

package/src/wire/RouteAddress.ts

@@ -1,11 +1,4 @@
-/** Which kind of destination served a call — it travels in a `CallRecord`. */
-export type RouteKind = 'local' | 'remote' | 'system';
-
-export interface RouteAddressInput {
-  entity: string;
-  operation: string;
-  surface?: string;
-}
+import type { RouteAddressInput } from './RouteAddressInput.js';
 
 /** Refuses an empty segment, so no address can be built that nothing can serve. */
 function required(value: string, name: string): string {

package/src/wire/RouteAddressInput.ts

@@ -0,0 +1,5 @@
+export interface RouteAddressInput {
+  entity: string;
+  operation: string;
+  surface?: string;
+}

package/src/wire/RouteKind.ts

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

package/src/wire/Rows.ts

@@ -0,0 +1,7 @@
+/**
+ * The row inside what an operation answers — the page reads rows whether the op returns a list,
+ * a page or a single one, so `items` is typed off this rather than off the whole answer.
+ */
+export type Rows<Answered> = Answered extends readonly (infer Row)[] ? Row
+  : Answered extends { items: readonly (infer Row)[] } ? Row
+  : Answered;

package/src/wire/RpcAnswer.ts

@@ -0,0 +1,7 @@
+import type { InvocationContext } from './InvocationContext.js';
+
+/** Reserved namespace — calls the runner answers itself, never a façade. */
+export const RPC_ENTITY = 'rpc';
+
+/** What an `rpc` op answers — the facade for what the app says about ITSELF, never about a row. */
+export type RpcAnswer = (invocation: InvocationContext, surface?: string) => unknown;

package/src/wire/Signature.ts

@@ -0,0 +1,13 @@
+import type { TypeRef } from './TypeRef.js';
+import type { Param } from './Param.js';
+
+/** A method's signature, as a contract is built from it — the shape, never the reading. */
+export interface Signature {
+  name: string;
+  params: Param[];
+  returnType?: TypeRef;
+  /** Came from a base class, not from the file being scanned. */
+  inherited?: boolean;
+  /** The operation in words — the first sentence of the method's doc comment. */
+  description?: string;
+}

package/src/wire/SignedCall.ts

@@ -0,0 +1,12 @@
+/** What a receiver accepts before it stops reading an input. */
+export const MAX_BODY_BYTES = 1024 * 1024;
+
+/** Everything a caller's envelope covers — the call as the sender meant it. */
+export interface SignedCall {
+  entity: string;
+  op: string;
+  params?: Record<string, unknown>;
+  query?: Record<string, unknown>;
+  input?: unknown;
+  state?: Record<string, unknown>;
+}

package/src/wire/Transport.ts

@@ -0,0 +1,5 @@
+import type { InvocationContext } from './InvocationContext.js';
+import type { FrondCall } from './FrondCall.js';
+
+/** A transport executes a call somewhere else. Failures surface as thrown FougereError. */
+export type Transport = (call: FrondCall, invocation: InvocationContext) => Promise<unknown>;

package/src/wire/{signature.ts → TypeRef.ts}

@@ -1,4 +1,3 @@
-/** A method's signature, as a contract is built from it — the shape, never the reading. */
 /** A type reference — primitives, entities, arrays, generics. */
 export interface TypeRef {
   /** Raw type text as written in source (e.g. 'Pagination<Post>'). */
@@ -18,21 +17,3 @@ export interface TypeRef {
   /** Whether this is a Promise wrapper (unwrapped in output). */
   promise?: boolean;
 }
-
-/** One parameter of a signature. */
-export interface Param {
-  name: string;
-  type: TypeRef;
-  optional?: boolean;
-}
-
-/** A method signature. */
-export interface Signature {
-  name: string;
-  params: Param[];
-  returnType?: TypeRef;
-  /** Came from a base class, not from the file being scanned. */
-  inherited?: boolean;
-  /** The operation in words — the first sentence of the method's doc comment. */
-  description?: string;
-}

package/src/wire/binding.ts

@@ -2,7 +2,7 @@
  * Where each parameter of an operation gets its value — decided once at boot from the parsed
  * signature, replayed per call by `resolveArgs`.
  */
-import type { Param } from './signature.js';
+import type { Param } from './Param.js';
 import { lowerFirst } from '@fougere/schema';
 
 // ── Types ─────────────────────────────────────

package/src/wire/card/CardOp.ts

@@ -0,0 +1,22 @@
+import type { SchemaDescriptor } from '@fougere/schema';
+import type { ErrorCode } from '../ErrorCode.js';
+
+/**
+ * One operation, as a stranger meets it — its name, what it is for, what it takes and whether it
+ * reads or writes.
+ */
+export interface CardOp {
+  name: string;
+  /** The author's own doc sentence, when the method carries one. */
+  description?: string;
+  /** JSON Schema of what it accepts, when the contract names a view. */
+  input?: SchemaDescriptor;
+  /** JSON Schema of what it emits, when the contract names one. */
+  output?: SchemaDescriptor;
+  /** `query` reads, `command` writes — the same call REST turns into GET vs POST. */
+  kind: 'query' | 'command';
+  /** How much `output` describes. */
+  cardinality?: 'one' | 'maybe' | 'many' | 'page' | 'none';
+  /** What this op can REFUSE, beyond what `kind` and `input` already imply. */
+  errors?: ErrorCode[];
+}

package/src/wire/card/IdentityCard.ts

@@ -0,0 +1,41 @@
+import type { SchemaDescriptor } from '@fougere/schema';
+import { ErrorCode } from '../ErrorCode.js';
+import { FougereError } from '../FougereError.js';
+import type { CardOp } from './CardOp.js';
+
+/** What an app hosts — the wire projection of its scanned fronds. */
+export interface IdentityCard {
+  fronds: {
+    name: string;
+    facades: {
+      name: string;
+      ops: CardOp[];
+      /** The shape stored under this name — **absent when nothing is**. */
+      schema?: SchemaDescriptor;
+    }[];
+    /** The facts this frond ANNOUNCES — one entry per `Emit<T>` its handlers inject. */
+    facts: { name: string; schema?: SchemaDescriptor }[];
+  }[];
+}
+
+/** The shape a card must have to be walked — `fronds`, and each frond's `facades`. */
+export function assertIdentityCard(value: unknown, source: string): IdentityCard {
+  const card = value as IdentityCard | undefined;
+  const fronds = Array.isArray(card?.fronds) ? card.fronds : undefined;
+  if (!fronds) throw cardRefusal(source, 'no fronds array');
+  for (const frond of fronds) {
+    if (!frond || typeof frond.name !== 'string') throw cardRefusal(source, 'a frond with no name');
+    if (!Array.isArray(frond.facades)) throw cardRefusal(source, `frond '${frond.name}' has no valid facades array`);
+  }
+  return card as IdentityCard;
+}
+
+function cardRefusal(source: string, what: string): FougereError {
+  return new FougereError({
+    code: ErrorCode.INTERNAL_ERROR,
+    message:
+      `${source} answered an invalid identity card: ${what}.\n`
+      + `  A card is what tells this process what the other one hosts, so nothing can be routed from it.\n`
+      + `  - Check that the address serves a Fougere app, and that its version still speaks this card.`,
+  });
+}

package/src/wire/drift.ts

@@ -1,26 +1,26 @@
 import { Card, type Change, type SchemaDescriptor } from '@fougere/schema';
-import type { IdentityCard } from './call.js';
+import type { IdentityCard } from './card/IdentityCard.js';
 
 /** What separates the copy a consumer holds from what the producer actually serves. */
 export interface CardDrift {
   frond: string;
-  /** A door the consumer calls that the producer no longer serves. */
+  /** A facade the consumer calls that the producer no longer serves. */
   missingDoors: string[];
-  /** An operation the consumer calls that the door no longer has. */
-  missingOps: { door: string; ops: string[] }[];
-  /** A shape that moved under a door the consumer still calls. */
-  shapes: { door: string; changes: Change[] }[];
+  /** An operation the consumer calls that the facade no longer has. */
+  missingOps: { facade: string; ops: string[] }[];
+  /** A shape that moved under a facade the consumer still calls. */
+  shapes: { facade: string; changes: Change[] }[];
   /** A fact the consumer subscribes to whose shape moved, or that is gone. */
   facts: { fact: string; changes: Change[] | 'gone' }[];
 }
 
-/** Every door of a card, by name. */
-function doorsOf(card: IdentityCard, frond: string): Map<string, { ops: Set<string>; schema?: SchemaDescriptor }> {
+/** Every facade of a card, by name. */
+function facadesOf(card: IdentityCard, frond: string): Map<string, { ops: Set<string>; schema?: SchemaDescriptor }> {
   const found = new Map<string, { ops: Set<string>; schema?: SchemaDescriptor }>();
   for (const one of card.fronds) {
     if (one.name !== frond) continue;
-    for (const door of one.doors) {
-      found.set(door.name, { ops: new Set(door.ops.map((op) => op.name)), schema: door.schema });
+    for (const facade of one.facades) {
+      found.set(facade.name, { ops: new Set(facade.ops.map((op) => op.name)), schema: facade.schema });
     }
   }
   return found;
@@ -37,23 +37,23 @@ function factsOf(card: IdentityCard, frond: string): Map<string, SchemaDescripto
 
 /** What a consumer's synced copy no longer matches in what the producer serves. */
 export function driftOf(mine: IdentityCard, theirs: IdentityCard, frond: string): CardDrift {
-  const mineDoors = doorsOf(mine, frond);
-  const served = doorsOf(theirs, frond);
+  const mineFacades = facadesOf(mine, frond);
+  const served = facadesOf(theirs, frond);
   const drift: CardDrift = { frond, missingDoors: [], missingOps: [], shapes: [], facts: [] };
 
-  for (const [name, door] of mineDoors) {
+  for (const [name, facade] of mineFacades) {
     const there = served.get(name);
     if (!there) { drift.missingDoors.push(name); continue; }
 
-    const missing = [...door.ops].filter((op) => !there.ops.has(op));
-    if (missing.length > 0) drift.missingOps.push({ door: name, ops: missing.sort() });
+    const missing = [...facade.ops].filter((op) => !there.ops.has(op));
+    if (missing.length > 0) drift.missingOps.push({ facade: name, ops: missing.sort() });
 
-    if (door.schema && there.schema) {
+    if (facade.schema && there.schema) {
       // `Card.diff` never guesses a rename — a field gone plus a field appeared lands in
       // `ambiguous`, and only a declaration settles it. Here nobody can declare one, so
       // the pair is reported as it is and a human reads it.
-      const moved = Card.fromDescriptor(door.schema).diff(Card.fromDescriptor(there.schema));
-      if (moved.changes.length > 0) drift.shapes.push({ door: name, changes: moved.changes });
+      const moved = Card.fromDescriptor(facade.schema).diff(Card.fromDescriptor(there.schema));
+      if (moved.changes.length > 0) drift.shapes.push({ facade: name, changes: moved.changes });
     }
   }
 
@@ -81,10 +81,10 @@ export function agrees(drift: CardDrift): boolean {
 /** The drift, in the words a deploy needs. */
 export function explain(drift: CardDrift): string[] {
   const lines: string[] = [];
-  for (const door of drift.missingDoors) lines.push(`${drift.frond}.${door} — you call it, it is not served`);
-  for (const { door, ops } of drift.missingOps) lines.push(`${drift.frond}.${door} — gone: ${ops.join(', ')}`);
-  for (const { door, changes } of drift.shapes) {
-    for (const change of changes) lines.push(`${drift.frond}.${door} — ${describe(change)}`);
+  for (const facade of drift.missingDoors) lines.push(`${drift.frond}.${facade} — you call it, it is not served`);
+  for (const { facade, ops } of drift.missingOps) lines.push(`${drift.frond}.${facade} — gone: ${ops.join(', ')}`);
+  for (const { facade, changes } of drift.shapes) {
+    for (const change of changes) lines.push(`${drift.frond}.${facade} — ${describe(change)}`);
   }
   for (const { fact, changes } of drift.facts) {
     if (changes === 'gone') { lines.push(`${fact} — you subscribe to it, it is no longer announced`); continue; }

package/src/wire/http-error.ts

@@ -1,6 +1,7 @@
 /** HTTP reading of an error — used by HTTP bridges (REST, Next, Inertia). */
-import { FougereError, ErrorCode } from './errors.js';
-import { Logger } from '../builtin/logger.js';
+import { ErrorCode } from './ErrorCode.js';
+import { FougereError } from './FougereError.js';
+import { Logger } from '../builtin/Logger.js';
 /**
  * An INTERNAL_ERROR is the one class of error whose message never leaves: it was not written for a
  * caller and may quote a path, a query or a row.
@@ -53,7 +54,7 @@ export function toHttpError(err: unknown): { status: number; body: ReturnType<Fo
     return { status: httpStatusFor(err.code), body: toPublicError(err) };
   }
   // A throw that never became a FougereError is masked by the same rule, so it goes
-  // through the same door rather than growing a second, quieter one here.
+  // through the same facade rather than growing a second, quieter one here.
   const framed = new FougereError({
     code: ErrorCode.INTERNAL_ERROR,
     message: (err as { message?: string })?.message ?? 'Internal error',

package/src/wire/loggerMiddleware.ts

@@ -1,8 +1,8 @@
 /**
  * Logger middleware — logs every operation with timing.
  */
-import type { AppMiddleware } from './middleware.js';
-import type { Logger } from '../builtin/logger.js';
+import type { AppMiddleware } from './AppMiddleware.js';
+import type { Logger } from '../builtin/Logger.js';
 import { CARRIES_LINE } from '../builtin/LogLine.js';
 
 /** Create a logger middleware that logs operation entry, exit, and errors. */