@fougere/core 0.5.0-alpha.1 → 0.7.0-alpha.0

package/src/entry/DynamicFacade.ts

@@ -1,28 +0,0 @@
-type Operation = (...args: any[]) => unknown;
-
-/** Facade for a remote contract whose operation names are not known before discovery. */
-export class DynamicFacade {
-  readonly operations: Record<string, Operation>;
-
-  constructor(private readonly operation: (name: string) => Operation) {
-    this.operations = new Proxy({}, {
-      get: (_target, name) => this.isOperationName(name) ? this.operation(name) : undefined,
-      has: (_target, name) => this.isOperationName(name),
-      getOwnPropertyDescriptor: (_target, name) => this.isOperationName(name)
-        ? {
-            value: this.operation(name),
-            writable: false,
-            enumerable: true,
-            configurable: true,
-          }
-        : undefined,
-    });
-  }
-
-  private isOperationName(name: string | symbol): name is string {
-    return typeof name === 'string'
-      && name !== 'then'
-      && name !== 'toJSON'
-      && !Object.hasOwn(Object.prototype, name);
-  }
-}

package/src/entry/FacadeEntry.ts

@@ -1,32 +0,0 @@
-import { Call } from '../contract/Call.js';
-import type { InvocationInput } from '../contract/Invocation.js';
-import { RouteAddress } from '../contract/RouteAddress.js';
-import type { DispatchPort } from '../dispatch/DispatchPort.js';
-import { DynamicFacade } from './DynamicFacade.js';
-
-/** Object-shaped entry that turns facade method calls into canonical dispatches. */
-export class FacadeEntry {
-  readonly operations: Record<string, Function>;
-
-  constructor(
-    private readonly dispatcher: DispatchPort,
-    private readonly entity: string,
-    operationNames?: Iterable<string>,
-    private readonly surface?: string,
-  ) {
-    this.operations = operationNames
-      ? Object.fromEntries([...operationNames].map((name) => [name, this.operation(name)]))
-      : new DynamicFacade((name) => this.operation(name)).operations;
-  }
-
-  private operation(name: string): (invocation?: InvocationInput) => Promise<unknown> {
-    return (invocation) => this.dispatcher.dispatch(new Call(
-      new RouteAddress({
-        entity: this.entity,
-        operation: name,
-        ...(this.surface !== undefined ? { surface: this.surface } : {}),
-      }),
-      invocation,
-    ));
-  }
-}

package/src/entry/TransportEntry.ts

@@ -1,30 +0,0 @@
-import { Call } from '../contract/Call.js';
-import { RouteAddress } from '../contract/RouteAddress.js';
-import type { DispatchPort } from '../dispatch/DispatchPort.js';
-import type { FrondCall, Transport } from '../wire/call.js';
-import type { InvocationContext } from '../contract/Invocation.js';
-
-/** Object entry for the historical transport contract. */
-export class TransportEntry {
-  constructor(
-    private readonly dispatcher: DispatchPort,
-    private readonly surface?: string,
-  ) {}
-
-  receive(legacy: FrondCall, invocation: InvocationContext): Promise<unknown> {
-    return this.dispatcher.dispatch(new Call(
-      new RouteAddress({
-        entity: legacy.entity,
-        operation: legacy.op,
-        ...(this.surface !== undefined ? { surface: this.surface } : {}),
-      }),
-      invocation,
-    ));
-  }
-}
-
-/** Adapt the historical transport signature to the canonical dispatch port. */
-export function createTransportEntry(dispatcher: DispatchPort, surface?: string): Transport {
-  const entry = new TransportEntry(dispatcher, surface);
-  return entry.receive.bind(entry);
-}

package/src/orm.ts

@@ -1,252 +0,0 @@
-import { upperFirst, type SchemaView } from '@fougere/schema';
-
-/** Options for list queries — pagination, sorting, counting. */
-export interface ListOptions {
-  /** Number of records to return. */
-  limit?: number;
-
-  /** Offset-based: skip N records. */
-  offset?: number;
-
-  /** Page-based: 1-indexed page number (requires limit). */
-  page?: number;
-
-  /** Cursor-based: fetch records after this ID. */
-  after?: string;
-
-  /** Field name to order by. */
-  orderBy?: string;
-
-  /** Sort direction (default: 'asc'). */
-  order?: 'asc' | 'desc';
-
-  /** If true, also returns total count (for pagination UIs). */
-  count?: boolean;
-
-  /**
-   * Equality criteria, field by field — `{ orderId: '…' }`. Named rather than spread
-   * across the options so an unknown key stays ignored instead of silently becoming a
-   * filter. `listBy(criteria)` is the same thing said as an intention.
-   */
-  where?: Record<string, unknown>;
-}
-
-/** Result of list() — extends Array so it's backward compatible. */
-export interface ListResult<T> extends Array<T> {
-  /** Total number of matching records (only set when count: true). */
-  total?: number;
-  /** Cursor of the last item (for cursor-based pagination). */
-  endCursor?: string;
-  /** Whether more records exist after endCursor. */
-  hasMore?: boolean;
-}
-
-/**
- * The keys `list()` answers to. Anything else is a mistake, and saying so is the point:
- * the façade refuses an unknown key in a CLIENT's input (`Unknown field`) — this applies the
- * same rule to the framework's own arguments. `list({ orderId })` used to be accepted and
- * the filter dropped, so a one-to-many relation quietly returned the whole table.
- */
-const LIST_OPTION_KEYS = [
-  'limit', 'offset', 'page', 'after', 'orderBy', 'order', 'count', 'where', 'select',
-] as const;
-
-/** Refuse an option the port does not answer to, naming it and what was expected. */
-export function assertListOptions(options: object | undefined, entity: string): void {
-  if (!options) return;
-  const legal = new Set<string>(LIST_OPTION_KEYS);
-  const strangers = Object.keys(options).filter((key) => !legal.has(key));
-  if (strangers.length === 0) return;
-  throw new Error(
-    `${entity}.list(): unknown option ${strangers.map((s) => `\`${s}\``).join(', ')}. ` +
-    `Known options are ${LIST_OPTION_KEYS.join(', ')} — to filter, pass \`where: { ${strangers[0]}: … }\`.`,
-  );
-}
-
-/** Select option — restrict returned fields to those of a SchemaView. */
-export interface SelectOption {
-  select?: SchemaView;
-}
-
-/** Per-entity ORM — scoped CRUD operations on a single entity type. */
-export interface EntityOrm<T = Record<string, unknown>> {
-  list(options?: ListOptions & SelectOption): Promise<ListResult<T>>;
-  findById(id: string, options?: SelectOption): Promise<T | undefined>;
-  /**
-   * Read by criteria — `findBy({ email })` for the one, `findAllBy({ orderId })` for the
-   * many, which is what a one-to-many relation *is*.
-   *
-   * Both existed on the SQL implementation from the start and neither was declared here.
-   * A port that hides what it offers is a port nobody can use: `auth-better` cast its way
-   * in (`orm as OrmWithFindBy`), a presenter that needed the lines of an order read the
-   * whole table instead, and the GraphQL relation resolver passed criteria to `list()`
-   * — which drops what it does not know.
-   */
-  findBy(criteria: Partial<T> | Record<string, unknown>, options?: SelectOption): Promise<T | undefined>;
-  findAllBy(criteria: Partial<T> | Record<string, unknown>, options?: SelectOption): Promise<T[]>;
-  /**
-   * Read a SET of rows by their key, in one go — the gesture every other one was
-   * being bent into.
-   *
-   * `findAllBy` compares with `=`, so a list of ids could not be passed to it; the
-   * only way to read N rows was `list()` then filter in memory, which is what 14 of
-   * 14 handlers of a real app measured on 2026-08-14 were doing. It is invisible on
-   * SQLite and it is the whole table the day the rows are not local.
-   *
-   * It answers a MAP, because the caller holds keys and not positions: a page zips
-   * against it by `get(row.authorId)`, a miss is the absence of a key, and a repeated
-   * key is one entry. The list form this replaced promised that zip and could not
-   * keep it — dropping a miss shifts every later position — so each caller rebuilt
-   * the very index the implementation had just thrown away.
-   */
-  findByKeys(ids: readonly string[], options?: SelectOption): Promise<Map<string, T>>;
-  /**
-   * Its dual: the rows that point AT each of these keys, grouped by the one they point at.
-   *
-   * `findByKeys` answers the side a row designates — one each, at most. This answers the
-   * side that designates the row — several each, and a key with none is simply absent.
-   * Together they are both directions of a relation, each in one query.
-   *
-   * Written because the page-shaped gesture only covered one of them: a presenter holding
-   * its page and wanting "the items of these lists" had no vocabulary for it and read the
-   * whole table instead, measured on a real app. `field` names the foreign key on THIS
-   * entity, the one carrying the value.
-   */
-  findAllByKeys(field: string, keys: readonly string[], options?: SelectOption): Promise<Map<string, T[]>>;
-  create(input: Partial<T>, options?: SelectOption): Promise<T>;
-  /**
-   * Write the row, or make the existing one look like this — one statement.
-   *
-   * What an import needs and the port did not have: `create` throws on the second run,
-   * so re-reading a source meant deleting first. Measured pulling an API twice.
-   *
-   * The key and the creation stamps survive an overwrite — a row keeps the moment it
-   * appeared. An engine with no upsert clause refuses by name rather than emulating
-   * one with a read in front, which would promise an atomicity it has not got.
-   */
-  upsert(input: Partial<T>, options?: SelectOption): Promise<T>;
-  /**
-   * A whole page in one statement — what an import writes through.
-   *
-   * Row by row, 500 rows were 500 statements (measured); the shape of an import is a
-   * page, so the write is one too. Answers how many rows were written rather than the
-   * rows: `create` hands back the complete row because a caller acts on it, and an
-   * import acts on none of them — re-reading a page for a symmetry nobody uses would
-   * double the work.
-   */
-  upsertAll(inputs: readonly Partial<T>[], options?: SelectOption): Promise<number>;
-  update(id: string, input: Partial<T>, options?: SelectOption): Promise<T>;
-  delete(id: string): Promise<boolean>;
-  /** Returns a scoped ORM that restricts all read results to the fields of the given schema. */
-  output(schema: SchemaView): EntityOrm<T>;
-  /**
-   * What this ORM wraps — the Kysely instance for the SQL one, something else elsewhere.
-   *
-   * Every judge sits on the ORM's own methods, so a statement issued here meets none of
-   * them: a value the entity refuses lands in the table without a word. It is the port's
-   * own escape hatch rather than a handle on the side, so it keeps the scope the container
-   * gave you — `productOrm.client` reaches the products, not the whole database.
-   *
-   * `unknown` on purpose: the client belongs to the implementation, and narrowing it is
-   * the caller saying out loud which one they are standing on.
-   */
-  readonly client: unknown;
-}
-
-/**
- * Factory that creates an EntityOrm for a given entity.
- * Called by bootstrap for every scanned entity.
- */
-export type OrmFactory = (entity: SchemaView, name: string) => EntityOrm;
-
-/**
- * Container key of an entity's storage — 'reading' → 'ReadingOrm'.
- *
- * The twin of {@link repositoryKeyOf} and of `facadeKeyOf`: the key of a thing
- * lives with the thing. This one was spelled by hand in four places in
- * `bootstrap.ts` and a fifth in `scanner.ts` — where the SCAN derives what a
- * constructor asks for. Two readers of one convention, neither of them naming it,
- * so a rename would have moved one and left the other resolving to nothing.
- */
-export function ormKeyOf(entity: string): string {
-  return `${upperFirst(entity)}Orm`;
-}
-
-/**
- * `Together<[Account, Ledger]>` — writes that stand or fall as one.
- *
- * `EntityOrm` is the port whose every gesture is ONE statement, and one statement is
- * atomic in every engine. This is the port whose unit is a BLOCK: what the callback did
- * happens entirely, or not at all. Nothing else separates them — the arity of the unit
- * of work is the whole distinction, which is why this lives here and not in a file of
- * its own.
- *
- * ```ts
- * constructor(private together: Together<[Account, Ledger]>) {}
- *
- * await this.together.run(async ([accounts, ledger]) => {
- *   await accounts.update(from, { balance: b - amount });
- *   await ledger.create({ from, to, amount });
- * });
- * ```
- *
- * **The second list is providers**, rebuilt inside the frame so that what THEY write is
- * covered too — a `Mirror` writes its pages through `EntityOrm<T>`, so naming it puts
- * them under the same unwind, with no locator and no second injection path:
- *
- * ```ts
- * constructor(private together: Together<[RateCard, Ledger], [RateMirror]>) {}
- *
- * await this.together.run(async ([rates, ledger], [mirror]) => { await mirror.refresh(); });
- * ```
- *
- * Two lists rather than one, because in a signature an entity and a provider are both
- * written as a class name and their instance types do not separate them — the type would
- * have to guess, by looking for methods or for a brand, and both answers are worse than
- * saying it. They are two different facts anyway: what the unwind covers, and what is
- * rebuilt to make that true.
- *
- * **All or nothing is the promise; isolation is not.** On one engine the members are
- * rebuilt over a transaction and the engine gives both. Across engines a transaction
- * cannot exist, so the frame keeps the before-image of each write and replays the
- * inverse in reverse order — the unwind holds, the isolation does not, and a reader
- * between two writes sees the half. The boot says which of the two it built rather
- * than letting the author assume the stronger one.
- */
-export interface Together<E extends readonly unknown[], P extends readonly unknown[] = []> {
-  run<R>(fn: (entities: { [K in keyof E]: EntityOrm<E[K]> }, providers: P) => Promise<R>): Promise<R>;
-}
-
-/**
- * The container key of a frame — `[['Account', 'Ledger'], ['RateMirror']]` →
- * 'Account+Ledger|RateMirrorTogether'.
- *
- * The DECLARED order, not a sorted one. The tuples are what the callback destructures, so
- * reordering here would hand `[ledger, accounts]` to a signature that says the opposite —
- * the type and the runtime disagreeing about the same line. Two orders of one frame are
- * therefore two keys and two registrations; they cost nothing, a frame holding no state
- * between runs.
- */
-export function togetherKeyOf(entities: readonly string[], providers: readonly string[] = []): string {
-  const named = entities.map(upperFirst).join(SEPARATOR);
-  return `${named}${providers.length ? KINDS + providers.map(upperFirst).join(SEPARATOR) : ''}${FRAME}`;
-}
-
-const FRAME = 'Together';
-const SEPARATOR = '+';
-/** Separates the two lists — what the unwind covers, and what is rebuilt to make it true. */
-const KINDS = '|';
-
-/**
- * The members behind a frame key, or `undefined` when the key is not one.
- *
- * The dual of the line above, and here for the reason `factOfEmitKey` is: the boot reads
- * the key back out of a handler's `deps` to know which frames to build. A key and the way
- * to undo it belong together — the pair that is split is the pair that drifts.
- */
-export function membersOfTogetherKey(key: string): { entities: string[]; providers: string[] } | undefined {
-  if (key.length <= FRAME.length || !key.endsWith(FRAME)) return undefined;
-  const [entities, providers = ''] = key.slice(0, -FRAME.length).split(KINDS);
-  const split = (list: string) => list.split(SEPARATOR).filter(Boolean);
-  return { entities: split(entities!), providers: split(providers) };
-}

package/src/scan/Fronds.ts

@@ -1,73 +0,0 @@
-import type { SchemaView } from '@fougere/schema';
-import type { EntityEntry, FrondDescriptor } from './frond.js';
-
-/**
- * What this app hosts — the scan's answer, with the questions everyone was asking it
- * by hand.
- *
- * The list was a bare array, so every reader re-walked it: "which frond owns this
- * entity" was spelled four times, "every entity by name" three times as three literal
- * copies of the same `Map`, and the two inside the boot even carried comments saying so.
- * A concept nobody can question is a concept everyone rebuilds.
- *
- * It IS an array — the same reason `ListResult` is one: twenty call sites iterate,
- * filter and spread it, and none of them is wrong to. `Symbol.species` is `Array` so a
- * `.map()` over it answers a plain array rather than something that claims to be a
- * hosting table and holds strings.
- */
-export class Fronds extends Array<FrondDescriptor> {
-  static override get [Symbol.species](): ArrayConstructor {
-    return Array;
-  }
-
-  /** What one scan run found. The only gate in — `Array.of` is taken, and named. */
-  static scanned(fronds: readonly FrondDescriptor[]): Fronds {
-    const held = new Fronds();
-    held.push(...fronds);
-    return held;
-  }
-
-  /** The frond that hosts an entity — `undefined` when no loaded frond does. */
-  owner(entity: string): FrondDescriptor | undefined {
-    return this.find((frond) => frond.entities.some((e) => e.name === entity));
-  }
-
-  /** The entity of that name, wherever it was scanned. */
-  entity(name: string): EntityEntry | undefined {
-    for (const frond of this) {
-      const found = frond.entities.find((e) => e.name === name);
-      if (found) return found;
-    }
-    return undefined;
-  }
-
-  /**
-   * Every scanned entity class, by name — across all fronds and never per-frond.
-   *
-   * A fact is announced in one frond and heard in another, so the subscriber's own
-   * frond does not hold the shape it must judge; a `reads:` clause names entities
-   * that belong to neighbours by definition.
-   */
-  schemas(): Map<string, SchemaView> {
-    return new Map(this.flatMap((frond) => frond.entities.map((e) => [e.name, e.entityClass] as const)));
-  }
-
-  /** Every scanned entity, sorted. What was FOUND, not what answers. */
-  entityNames(): string[] {
-    return this.flatMap((frond) => frond.entities.map((e) => e.name)).sort();
-  }
-
-  /**
-   * The names a call may address, sorted — what a NOT_FOUND must print.
-   *
-   * Not `entityNames()`, which is what the scan found: an entity with no handler is
-   * scanned and serves nothing, so the refusal read *"Entity 'indexed' is not hosted
-   * here. Hosted here: indexed."* — naming the very thing it had just refused. A façade
-   * is keyed on a HANDLER's address, and that is what this lists.
-   */
-  servedNames(surface?: string): string[] {
-    return this.flatMap((frond) => frond.handlers
-      .filter((handler) => (handler.surface ?? undefined) === surface)
-      .map((handler) => handler.address)).sort();
-  }
-}

package/src/scan/frond.ts

@@ -1,235 +0,0 @@
-/**
- * A frond as the SCAN found it — one interface per convention directory, plus what the
- * run could not read.
- *
- * The declared side is `frond-config.ts`; this is the described one. They meet at
- * `FrondDescriptor.operationsOverrides`, where a declaration reaches the façade.
- */
-import type { SchemaView } from '@fougere/schema';
-import type { ParsedParam, OperationContract, OperationsMap } from '../wire/operation.js';
-import type { PresenterViews } from '../prefab/presenter.js';
-import type { Fronds } from './Fronds.js';
-
-/**
- * A discovered provider — a class under `services/` or `repositories/`, injected by type.
- *
- * Which of the two directories it came from is deliberately not recorded. The scan used
- * to tag it `kind: 'service' | 'repository'`, a field it filled on every provider and
- * that **no consumer ever read** — the two directories are two spellings of the same
- * thing, and DI resolves by type either way.
- */
-export interface ProviderEntry {
-  /**
-   * The class constructor (default export of the file).
-   *
-   * `never[]` and not `unknown[]`: the arguments are the CONTAINER's to supply, so the
-   * slot must accept any constructor — and with `unknown[]` a real class is refused,
-   * because assigning it would need `unknown` to be one of its declared parameters.
-   * Invisible on the scan path, where the value arrives as `unknown` and is cast; the
-   * module `fougere build` writes states the class by name, and that is where it showed.
-   */
-  ctor: new (...args: never[]) => unknown;
-  /** Constructor dependency type names (from AST scan). */
-  deps: string[];
-  /** Absolute file path (for debugging). */
-  filePath: string;
-}
-
-/** A discovered entity (Entity subclass in entities/ dir). */
-export interface EntityEntry {
-  /** Registration key: class name lowercased first char (e.g. 'product'). */
-  name: string;
-  /** The Entity class (has static getFields()). */
-  entityClass: SchemaView;
-  /** Absolute file path (for debugging). */
-  filePath: string;
-  /** Whether this entity is part of the frond's public contract. */
-  exposed?: boolean;
-}
-
-/** A discovered handler (controls what a service exposes). */
-export interface HandlerEntry {
-  /** Registration key (e.g. 'postHandler'). */
-  name: string;
-  /**
-   * The name this handler answers to — its class name minus `Handler`, lowercased
-   * (`PostHandler` → `post`). It is what `facadeKeyOf` builds its key from and what
-   * travels as `FrondCall.entity` on the wire.
-   *
-   * **It is NOT an entity name**, and it was called `entityName` for long enough to
-   * mislead: `toEntityName` (`scanner.ts`) strips the suffix without checking that any
-   * entity carries the result, and the boot states the consequence — *pointing at
-   * nothing is legal*. A health check, a search across several shapes, a pure
-   * computation: ordinary handlers that own no row. `PresenterEntry`/`CollectorEntry`
-   * keep `entityName` because those really do target a declared entity.
-   */
-  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 ORM output. */
-  outputOverride?: SchemaView;
-  /** Surface name — subdirectory in handlers/ (e.g. 'admin', 'public'). */
-  surface?: string;
-}
-
-/** Return type metadata for a presenter computed field. */
-export interface PresenterFieldMeta {
-  name: string;
-  /** Inferred return type name: 'string', 'number', 'boolean', or a class name. */
-  returnType?: string;
-  /**
-   * The field emits a LIST per row — `tags(posts: Post[]): string[][]`.
-   *
-   * The method answers one value per row, so the outer array level of its return type is
-   * the page, not the field: what remains after removing it is the field's own arity.
-   * Nothing measured that remainder, so a computed list and a computed scalar looked
-   * identical and every projection announced the scalar.
-   */
-  list?: boolean;
-  /** Whether the return is nullable. */
-  nullable?: boolean;
-  /**
-   * The declared parameters AFTER the rows. Kept raw rather than resolved: the scan
-   * meets presenters before collectors, so the plan is computed at boot where the
-   * collector names are known — exactly as a handler op's is.
-   *
-   * A computed field that declares `user?: User` is then fed by the collector
-   * that resolves one. A presenter is not a second mechanism.
-   */
-  params?: ParsedParam[];
-}
-
-/** A discovered presenter (computed fields for an entity's output). */
-export interface PresenterEntry {
-  /** 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). */
-  fieldMeta: PresenterFieldMeta[];
-  /**
-   * The view each computed field emits, when the presenter declares one
-   * (`Presenter(Order, { items: [OrderItemView] })`). Stated rather than inferred: the
-   * parser reads a scalar off a return type and nothing more, so an object-valued field
-   * has no derivable shape without this.
-   */
-  views?: PresenterViews;
-  /** Constructor dependency type names (from AST scan). */
-  deps: string[];
-  /** Absolute file path (for debugging). */
-  filePath: string;
-}
-
-/** A discovered collector (resolves handler input params from invocation context). */
-export interface CollectorEntry {
-  /** 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;
-}
-
-/** A discovered seed file (array of records or async factory). */
-export interface SeedEntry {
-  /** Entity name this seed targets (from filename: Author.seed.ts → 'author'). */
-  entityName: string;
-  /** Raw default export — array or function. Resolved at runtime. */
-  data: Record<string, unknown>[] | SeedFactory;
-  /** Absolute file path (for debugging). */
-  filePath: string;
-}
-
-/** Seed factory — receives a resolver to access handlers cross-frond. */
-export type SeedFactory = (resolve: <T>(name: string) => T) => Promise<Record<string, unknown>[]>;
-
-/** Where a frond lives on disk. */
-export interface FrondSource {
-  /** Absolute path to the frond directory. */
-  path: string;
-  /** The @fronds/{name} package name. Always present. */
-  package: string;
-}
-
-export interface FrondDescriptor {
-  name: string;
-  source: FrondSource;
-  providers: ProviderEntry[];
-  entities: EntityEntry[];
-  handlers: HandlerEntry[];
-  presenters: PresenterEntry[];
-  collectors: CollectorEntry[];
-  seeds: SeedEntry[];
-  /** 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. Key = operation name.
-   *
-   * Two depths, as declared on {@link OperationOverride}: the surface keys travel to the
-   * transport adapters, the contract keys (`input`/`output`/`binding`) travel to the
-   * façade — where config is the third producer of an operation's contract, alongside a
-   * prefab's `__ops` and the scan.
-   */
-  operationsOverrides?: Record<string, OperationContract & {
-    kind?: 'query' | 'command';
-    /** Class name to resolve from DI (overrides default `{Entity}Handler` lookup). */
-    handlerName?: string;
-    /** Method name on the resolved handler (defaults to op name). */
-    method?: string;
-  }>;
-}
-
-/** Result of scanning a project directory. */
-/**
- * Something the scan could NOT do — recorded instead of swallowed.
- *
- * The scan answers with what it found. Until now it answered the same way whether
- * a directory held nothing or could not be read, and whether a handler declared no
- * operation or failed to parse: `catch → empty`. So every downstream reader — the
- * façade, the identity card, anything asking "what does this app serve?" — could
- * not tell **"there is nothing"** from **"I could not look"**.
- *
- * That distinction is what makes a rule about an ABSENCE sound. Without it, a check
- * derived from the scan reports "nothing wrong" precisely when it read nothing.
- */
-export interface ScanDiagnostic {
-  /**
-   * `blocking` — the app now serves less than its source declares, and no caller
-   * can know it: a handler that failed to parse contributes zero operations.
-   * `warning` — something may be missing and the scan cannot decide, e.g. a base
-   * class it is not allowed to resolve. Statable in `frond.config.ts`.
-   */
-  severity: 'blocking' | 'warning';
-  /** Stable rule name — `handler-parse-failed`, `directory-unreadable`. */
-  code: string;
-  /** Absolute path of what could not be read. */
-  filePath: string;
-  /** The frond it belongs to, when the scan got far enough to know. */
-  frond?: string;
-  /** The declaration the diagnostic is about — e.g. `PostHandler.publish`. */
-  subject?: string;
-  /** What could not be done, and what it costs. One sentence, for a human. */
-  message: string;
-  /** The underlying failure, kept whole. */
-  cause?: unknown;
-}
-
-export interface ScanResult {
-  fronds: Fronds;
-  /** What the scan could not do. Empty is a claim, not a default — see {@link ScanDiagnostic}. */
-  diagnostics: ScanDiagnostic[];
-}