@fougere/core 0.3.0-alpha.0 → 0.5.0-alpha.0

package/src/prefab/presenter.ts

@@ -0,0 +1,63 @@
+/**
+ * Presenter(Entity) — enriches an entity's output with computed fields.
+ *
+ * Each method on the presenter is a computed field resolver:
+ * - Receives the entity record as first argument
+ * - Can be sync or async
+ * - Injected via DI (constructor params resolved by the container)
+ *
+ * Usage:
+ * ```ts
+ * export default class PostPresenter extends Presenter(Post) {
+ *   constructor(private commentOrm: CommentOrm) { super(); }
+ *
+ *   excerpt(post: Post) {
+ *     return post.body.slice(0, 200);
+ *   }
+ *
+ *   async commentCount(post: Post) {
+ *     return this.commentOrm.countFor(post.id);
+ *   }
+ * }
+ * ```
+ */
+
+import { upperFirst, type EntityConstructor } from '@fougere/schema';
+
+/**
+ * The view a computed field emits — `OrderItemView` for one, `[OrderItemView]` for many.
+ * A view is a schema, so it derives: `Order.pick('id', 'status')`, never a hand-written type.
+ */
+export type PresenterViews = Record<string, EntityConstructor | [EntityConstructor]>;
+
+/**
+ * `Presenter(Order, { items: [OrderItemView], user: UserCard })` — the second argument names
+ * the view each computed field emits, exactly as `Crud(Post, { list: PostCard })` names an
+ * op's. What fabricates a field declares its contract, and it declares it **once**: the
+ * façade applies the presenter (see `PresenterExecutor`), and every surface reads the same statement
+ * instead of guessing.
+ *
+ * Guessing was the cost of not stating it. The scan can read a scalar off a return type and
+ * nothing more, so a field returning an object had no derivable shape: the GraphQL projection
+ * fell back to a serialized `String`, and a client asking `items { quantity }` got a schema
+ * error on a field REST served whole. Declaring is optional — a scalar field needs nothing,
+ * and an undeclared object keeps the old behaviour.
+ */
+export function Presenter<E extends EntityConstructor>(entity: E, views?: PresenterViews) {
+  class PresenterBase {
+    static readonly __entity = entity;
+    static readonly __views = views;
+  }
+  return PresenterBase;
+}
+
+/** List computed field names from a presenter class (own methods minus constructor). */
+export function getPresenterFields(ctor: Function): string[] {
+  return Object.getOwnPropertyNames(ctor.prototype)
+    .filter((name) => name !== 'constructor' && typeof ctor.prototype[name] === 'function');
+}
+
+/** Container key of an entity's presenter — 'post' → 'PostPresenter'. */
+export function presenterKeyOf(entity: string): string {
+  return `${upperFirst(entity)}Presenter`;
+}

package/src/prefab/repository.ts

@@ -0,0 +1,170 @@
+import { upperFirst, type EntityConstructor } from '@fougere/schema';
+import type { EntityOrm, ListOptions, ListResult, SelectOption } from '../orm.js';
+import type { SchemaView } from '@fougere/schema';
+
+/**
+ * Repository(…entities) — who owns an entity's storage, and where its questions are named.
+ *
+ * **The arity decides**, which is the second reading of what `orm.ts` already states for
+ * `EntityOrm` against `Together`: the arity of the unit is the whole distinction.
+ *
+ * ONE entity — the repository IS that entity's storage, with your methods added. The port's
+ * thirteen gestures are forwarded, so a handler reads `this.posts.list()` whether or not
+ * anyone wrote the file, and a named question sits beside them:
+ *
+ * ```ts
+ * // repositories/PostRepository.ts
+ * export default class PostRepository extends Repository(Post) {
+ *   published() {
+ *     return this.list({ where: { status: 'published' }, orderBy: 'publishedAt', order: 'desc' });
+ *   }
+ * }
+ * ```
+ *
+ * TWO OR MORE — an aggregate. It owns them: nothing else in the app is handed their
+ * storage, and no gesture is forwarded (which entity would `create` write to?), so the only
+ * way in is a method this class names. That is what lets a rule spanning two tables exist:
+ * it is ordinary TypeScript inside the method that does the writing.
+ *
+ * ```ts
+ * // repositories/CommandeRepository.ts
+ * export default class CommandeRepository extends Repository(Commande, Stock) {
+ *   avecLignes(id: string) {
+ *     const [commandes, stock] = this.orms;
+ *     …
+ *   }
+ * }
+ * ```
+ *
+ * `this.orms` is protected, because the whole point is that the storage stops at this file.
+ * `protected` is erased at runtime, like `abstract` on a port: a compile-time guarantee, not
+ * a barrier. The same bargain, already accepted.
+ *
+ * **The boundary is not the unit of work.** An aggregate says the rules of these entities
+ * hold together; a frame says these writes land together, and the two lists coincide only
+ * often. Deriving the frame from the membership would make a read-only aggregate carry one
+ * — refusals included, and `registerFrames` refuses without storage or over `remotes:` —
+ * and would put `Together<[Commande, Stock], [StockMirror]>` out of reach forever. So a
+ * frame is ASKED FOR here as anywhere else, which is what makes it declared:
+ *
+ * ```ts
+ * constructor(commandes: CommandeOrm, stock: StockOrm, private frame: Together<[Commande, Stock]>) {
+ *   super(commandes, stock);
+ * }
+ * ```
+ *
+ * The ORM words come back in that line, and only there: this class IS the holder, which is
+ * the one case `boot/ownership.ts` lets name the storage it was built on.
+ *
+ * A repository is NOT a door: it has no façade, so nothing here is reachable from the wire.
+ */
+
+/**
+ * The shape a repository of ONE entity has — the port itself, plus whatever the subclass
+ * names on top. Written by an author who has not written the file: `RepositoryOf<Post>` is
+ * to `PostRepository` what `EntityOrm<Post>` is to `PostOrm`, one spelling of one key, and
+ * `depKeyOf` reads both.
+ */
+export type RepositoryOf<T> = EntityOrm<T>;
+
+/** The single-entity form: the port, plus whatever the subclass names. */
+export interface RepositoryConstructor<T> {
+  new (orm: EntityOrm<T>): EntityOrm<T>;
+  readonly __entity: unknown;
+}
+
+/**
+ * What an aggregate's subclass sees: the storage of the members it owns, in declared order,
+ * and `protected` — the storage stops at that file, which is the whole mechanism.
+ *
+ * A class and not an interface, because `protected` cannot be spelled in one. Ambient: the
+ * value it describes is fabricated by `many()` for an arity only known at the call.
+ */
+declare abstract class AggregateShape<E extends readonly EntityConstructor[]> {
+  protected orms: { [K in keyof E]: EntityOrm<InstanceType<E[K]>> };
+}
+
+/** The tuple an aggregate holds — the readable form of {@link AggregateShape}'s member. */
+export type AggregateOf<E extends readonly EntityConstructor[]> =
+  { [K in keyof E]: EntityOrm<InstanceType<E[K]>> };
+
+export type AggregateConstructor<E extends readonly EntityConstructor[]> =
+  (new (...orms: unknown[]) => AggregateShape<E>) & {
+    readonly __entity: unknown;
+    /** The entities this class owns. Present from two on — an owner of one owns nothing. */
+    readonly __owns: E;
+  };
+
+export function Repository<E extends EntityConstructor>(entity: E): RepositoryConstructor<InstanceType<E>>;
+export function Repository<E extends readonly [EntityConstructor, EntityConstructor, ...EntityConstructor[]]>(
+  ...entities: E
+): AggregateConstructor<E>;
+export function Repository(...entities: EntityConstructor[]): unknown {
+  return entities.length === 1 ? one(entities[0]) : many(entities);
+}
+
+/**
+ * The port forwarded, member by member. Written out rather than proxied: a Proxy would
+ * answer every name including the ones the port does not have, and this file would then
+ * state the surface nowhere. Thirteen lines against one declaration that can be read.
+ */
+function one<E extends EntityConstructor>(entity: E): RepositoryConstructor<InstanceType<E>> {
+  type T = InstanceType<E>;
+
+  class RepositoryBase implements EntityOrm<T> {
+    static readonly __entity = entity;
+
+    constructor(protected orm: EntityOrm<T>) {}
+
+    list(options?: ListOptions & SelectOption): Promise<ListResult<T>> { return this.orm.list(options); }
+    findById(id: string, options?: SelectOption) { return this.orm.findById(id, options); }
+    findBy(criteria: Partial<T> | Record<string, unknown>, options?: SelectOption) { return this.orm.findBy(criteria, options); }
+    findAllBy(criteria: Partial<T> | Record<string, unknown>, options?: SelectOption) { return this.orm.findAllBy(criteria, options); }
+    findByKeys(ids: readonly string[], options?: SelectOption) { return this.orm.findByKeys(ids, options); }
+    findAllByKeys(field: string, keys: readonly string[], options?: SelectOption) { return this.orm.findAllByKeys(field, keys, options); }
+    create(input: Partial<T>, options?: SelectOption) { return this.orm.create(input, options); }
+    upsert(input: Partial<T>, options?: SelectOption) { return this.orm.upsert(input, options); }
+    upsertAll(inputs: readonly Partial<T>[], options?: SelectOption) { return this.orm.upsertAll(inputs, options); }
+    update(id: string, input: Partial<T>, options?: SelectOption) { return this.orm.update(id, input, options); }
+    delete(id: string) { return this.orm.delete(id); }
+    output(schema: SchemaView) { return this.orm.output(schema); }
+    get client(): unknown { return this.orm.client; }
+  }
+
+  return RepositoryBase as unknown as RepositoryConstructor<T>;
+}
+
+/**
+ * The aggregate. Its constructor takes the members' storage in the DECLARED order — the
+ * order `toProvider` fills its `deps` with, and the order a subclass hands back to `super()`
+ * when it declares a constructor of its own.
+ */
+function many<E extends readonly EntityConstructor[]>(entities: E): AggregateConstructor<E> {
+  class AggregateBase {
+    static readonly __entity = entities[0];
+    static readonly __owns = entities;
+
+    protected orms: AggregateOf<E>;
+
+    constructor(...orms: unknown[]) {
+      this.orms = orms.slice(0, entities.length) as AggregateOf<E>;
+    }
+  }
+
+  return AggregateBase as unknown as AggregateConstructor<E>;
+}
+
+/** Container key of an entity's repository — 'reading' → 'ReadingRepository'. */
+export function repositoryKeyOf(entity: string): string {
+  return `${upperFirst(entity)}Repository`;
+}
+
+/**
+ * The entities a class owns — empty for anything that is not an aggregate.
+ *
+ * Read from the mark rather than from the constructor, for the reason `Crud.__ops` exists:
+ * the AST scan is workspace-only, so an installed prefab resolves to nothing.
+ */
+export function ownedBy(ctor: unknown): readonly EntityConstructor[] {
+  return (ctor as { __owns?: readonly EntityConstructor[] } | undefined)?.__owns ?? [];
+}

package/src/scan/Fronds.ts

@@ -0,0 +1,73 @@
+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/bundling.ts

@@ -0,0 +1,25 @@
+/**
+ * What a Fougere boot loads at RUNTIME, so a bundler must leave it alone.
+ *
+ * Stated once because it was stated twice and the two had already drifted: the Vite plugin
+ * listed `@fougere/schema`, `@fougere/adapter-graphql` and `@fougere/auth-better`, the Next
+ * one did not, and BOTH omitted the two packages `@fougere/app`'s boot actually imports
+ * dynamically — `@fougere/defaults` and `@fougere/transport-http`. A list a bundler reads
+ * has no way to notice it is wrong: nothing fails at build time, the app fails at boot.
+ *
+ * It sits here rather than beside the dynamic imports because both readers are BUILD-TIME
+ * plugins that already depend on core, and neither may pull the boot into a bundler config.
+ */
+export const RUNTIME_PACKAGES: readonly string[] = [
+  '@fougere/app',
+  '@fougere/core',
+  '@fougere/schema',
+  '@fougere/defaults',
+  '@fougere/transport-http',
+  '@fougere/adapter-sql',
+  '@fougere/adapter-graphql',
+  '@fougere/auth-better',
+  'better-sqlite3',
+  'jiti',
+  'typescript',
+];

package/src/scan/conventions.ts

@@ -0,0 +1,122 @@
+/**
+ * The names the scan READS instead of deriving them.
+ *
+ * Everything else a frond states, it states by its shape; these seven directories and the
+ * import prefix are the one place where a name is the declaration. They were spelled as
+ * literals in five packages, so a project could not move any of them and `frondsDir` was
+ * a declared key with no reader.
+ */
+import { join } from 'node:path';
+
+export interface Conventions {
+  /**
+   * The scope a frond's package name carries — `@fronds/blog`.
+   *
+   * A real package name, not only an alias: the CLI writes it as `name` in a scaffolded
+   * frond and as a `workspace:*` dependency in the app that consumes it.
+   */
+  scope: string;
+  /** The directory holding fronds, below the project root. */
+  fronds: string;
+  /** Directory per role. The role is the key; the name on disk is the value. */
+  dirs: {
+    entities: string;
+    handlers: string;
+    services: string;
+    repositories: string;
+    presenters: string;
+    collectors: string;
+    seeds: string;
+    /** What its shapes used to be — written by `fougere freeze`, replayed by `migrate`. */
+    versions: string;
+  };
+}
+
+/**
+ * What a project means when it declares nothing — the convention itself.
+ *
+ * `@fronds` and not `@frond`: the npm org for the singular belongs to someone else, and a
+ * scope is a name that must be ownable.
+ */
+export const DEFAULT_CONVENTIONS: Conventions = {
+  scope: '@fronds',
+  fronds: 'fronds',
+  dirs: {
+    entities: 'entities',
+    handlers: 'handlers',
+    services: 'services',
+    repositories: 'repositories',
+    presenters: 'presenters',
+    collectors: 'collectors',
+    seeds: 'seeds',
+    versions: 'versions',
+  },
+};
+
+/** What a `fougere.config.ts` may state: only the names that differ. */
+export type ConventionsInput = {
+  scope?: string;
+  fronds?: string;
+  dirs?: Partial<Conventions['dirs']>;
+};
+
+/**
+ * The convention, with a project's exceptions folded in.
+ *
+ * Merged one level into `dirs` so renaming one directory does not require restating the
+ * other six — the same reading `sources:` and `ports:` get, where only the exception is
+ * declared.
+ */
+export function resolveConventions(input?: ConventionsInput): Conventions {
+  return {
+    scope: input?.scope ?? DEFAULT_CONVENTIONS.scope,
+    fronds: input?.fronds ?? DEFAULT_CONVENTIONS.fronds,
+    dirs: { ...DEFAULT_CONVENTIONS.dirs, ...input?.dirs },
+  };
+}
+
+/** The package name a frond answers to. */
+export function frondPackage(name: string, conventions: Conventions): string {
+  return `${conventions.scope}/${name}`;
+}
+
+/**
+ * Directories whose classes register as providers — two spellings, one behaviour.
+ *
+ * A project may point both roles at one directory; the scan must then read it once, or
+ * every provider would be registered twice.
+ */
+export function providerDirsOf(conventions: Conventions): string[] {
+  return [...new Set([conventions.dirs.services, conventions.dirs.repositories])];
+}
+
+/**
+ * The frond vocabulary — every directory the scan reads.
+ *
+ * What a reader needs to bound a frond: the Nuxt module watches these for the root frond
+ * (watching the root itself would match every write), and a flat app's tsconfig lists
+ * them instead of `["."]`, which would swallow `app/` and `nuxt.config.ts`.
+ */
+export function frondDirsOf(conventions: Conventions): string[] {
+  const { entities, handlers, presenters, collectors, seeds, versions } = conventions.dirs;
+  return [...new Set([
+    entities, handlers, presenters, collectors, seeds, versions, ...providerDirsOf(conventions),
+  ])];
+}
+
+/**
+ * What changes when a frond's domain changes — the paths a dev loop watches.
+ *
+ * The root frond IS the scan root, so watching its path would match every write in the
+ * project: `.nuxt/`, `node_modules/`, the build output. Its convention directories are
+ * the frond, and they are what a scan re-reads.
+ */
+export function watchPathsOf(
+  frond: { source: { path: string } },
+  scanRoot: string,
+  conventions: Conventions,
+): string[] {
+  return frond.source.path === scanRoot
+    ? frondDirsOf(conventions).map((dir) => join(scanRoot, dir))
+    : [frond.source.path];
+}

package/src/scan/declare.ts

@@ -0,0 +1,188 @@
+/**
+ * A frond stated by its author, for an app that will not scan.
+ *
+ * The scan reads the type checker because a signature IS a declaration — and that reading
+ * has to happen while the types still exist, which is build time. An app that wants
+ * neither a build step nor `typescript` at runtime says the same thing here instead, and
+ * `createApp` cannot tell the difference: it consumes a `ScanResult`, never a scanner.
+ *
+ * What it does NOT ask for is the point. Every name the scan derives from a class is
+ * derived here the same way — `PostHandler` answers at `post`, `Post` is stored as `post`
+ * — so a declaration states classes and nothing else. `filePath` is empty because there is
+ * no file to point at, and a diagnostic that would have quoted one says so plainly.
+ *
+ * Measured on `demos/nuxt-blog`: 23 of its 29 operations need no word here at all, because
+ * `Crud.__ops` declares them at runtime. Only the six the author wrote by hand cost
+ * anything, and they cost `frond.config.ts` — where what is not derivable is stated.
+ */
+import { lowerFirst, type SchemaView } from '@fougere/schema';
+import type {
+  CollectorEntry, EntityEntry, FrondDescriptor, HandlerEntry,
+  PresenterEntry, ProviderEntry, SeedEntry,
+} from './frond.js';
+import { DEFAULT_CONVENTIONS } from './conventions.js';
+import { getPresenterFields } from '../prefab/presenter.js';
+
+/** A class, as a declaration hands it over: the constructor itself. */
+type Ctor = new (...args: never[]) => unknown;
+
+/**
+ * What a subject needs beyond its class, when its constructor names a frame or a port.
+ *
+ * `deps` is the one thing no runtime can recover: TypeScript erases the parameter types,
+ * and `registerFrames` reads them to know which frames to build — asking for one IS
+ * declaring it. A handler that takes only its own entity's ORM needs nothing here.
+ */
+export interface DeclaredSubject {
+  ctor: Ctor;
+  deps?: string[];
+}
+
+/** A handler, and the surface it answers on when it is not the default one. */
+export interface DeclaredHandler extends DeclaredSubject {
+  /**
+   * The scan reads this from the directory (`handlers/public/`), so a statement has to
+   * say it: two handlers over one entity collide on their address otherwise, and the
+   * refusal names the same route twice.
+   */
+  surface?: string;
+}
+
+/** A class on its own, or a class with what it asks for. */
+export type Declared = Ctor | DeclaredSubject;
+
+const ctorOf = (d: Declared): Ctor => (typeof d === 'function' ? d : d.ctor);
+
+/**
+ * What a prefab was BUILT ON — `Presenter(Post)` and `Collector(User)` both keep it under
+ * `__entity`, which is the only place it survives: nothing in the FORM of `PostPresenter`
+ * says `Post`. Absent, the class did not come through the prefab, and the refusal says so
+ * rather than yielding a frond whose presenter belongs to no entity.
+ */
+function subjectOf(ctor: Ctor, kind: string): { name: string } {
+  const subject = (ctor as unknown as { __entity?: { name: string } }).__entity;
+  if (!subject?.name) {
+    throw new Error(
+      `${ctor.name} is declared as a ${kind} but does not extend ${kind === 'presenter' ? 'Presenter(Entity)' : 'Collector(Type)'}, `
+      + `so what it is about cannot be read.`,
+    );
+  }
+
+  return subject;
+}
+const depsOf = (d: Declared): string[] => (typeof d === 'function' ? [] : d.deps ?? []);
+
+/** `PostHandler` answers at `post` — the same rule the scan applies to a file it found. */
+function addressOf(className: string): string {
+  const base = className.endsWith('Handler') ? className.slice(0, -7) : className;
+
+  return lowerFirst(base);
+}
+
+/** What a declaration states about one frond. Everything else is derived from the classes. */
+export interface FrondDeclaration {
+  entities?: SchemaView[];
+  handlers?: (Ctor | DeclaredHandler)[];
+  presenters?: (Ctor | DeclaredSubject)[];
+  collectors?: (Ctor | DeclaredSubject)[];
+  providers?: Declared[];
+  seeds?: { entityName: string; data: SeedEntry['data'] }[];
+  /** 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. */
+  scope?: string;
+}
+
+/**
+ * State a frond without reading a disk.
+ *
+ * ```ts
+ * createApp({
+ *   scan: { fronds: Fronds.scanned([frond('blog', { entities: [Post], handlers: [PostHandler] })]), diagnostics: [] },
+ * })
+ * ```
+ */
+export function frond(name: string, declared: FrondDeclaration = {}): FrondDescriptor {
+  const scope = declared.scope ?? DEFAULT_CONVENTIONS.scope;
+
+  const entities: EntityEntry[] = (declared.entities ?? []).map((entityClass) => ({
+    name: lowerFirst((entityClass as { name: string }).name),
+    entityClass,
+    filePath: '',
+    exposed: true,
+  }));
+
+  const handlers: HandlerEntry[] = (declared.handlers ?? []).map((h) => {
+    const ctor = ctorOf(h);
+    const surface = typeof h === 'function' ? undefined : h.surface;
+    const address = addressOf(ctor.name);
+
+    return {
+      name: ctor.name,
+      address,
+      ctor,
+      // A handler about no stored row is ordinary — the address is not a promise that an
+      // entity carries it, which is why this is not looked up.
+      entityName: address,
+      operations: new Map(),
+      deps: depsOf(h),
+      filePath: '',
+      exposed: true,
+      ...(surface ? { surface } : {}),
+    };
+  });
+
+  // Read off the class, never restated: `Presenter(Post)` keeps `Post` in `__entity` and a
+  // computed field IS a method, which `getPresenterFields` already reads from the prototype.
+  // Asking for `entityName` and `fields` made a statement copy what the class carries — and
+  // a copy that drifts silently, since nothing compares the two.
+  const presenters: PresenterEntry[] = (declared.presenters ?? []).map((p) => {
+    const ctor = ctorOf(p);
+    const fields = getPresenterFields(ctor);
+
+    return {
+      entityName: lowerFirst(subjectOf(ctor, 'presenter').name),
+      ctor,
+      fields,
+      fieldMeta: fields.map((field) => ({ name: field })),
+      deps: depsOf(p),
+      filePath: '',
+    };
+  });
+
+  // `Collector(User)` keeps `User` the same way — the type a handler names to receive it.
+  const collectors: CollectorEntry[] = (declared.collectors ?? []).map((c) => {
+    const ctor = ctorOf(c);
+
+    return {
+      typeName: subjectOf(ctor, 'collector').name,
+      ctor,
+      deps: depsOf(c),
+      filePath: '',
+    };
+  });
+
+  const providers: ProviderEntry[] = (declared.providers ?? []).map((p) => ({
+    ctor: ctorOf(p),
+    deps: depsOf(p),
+    filePath: '',
+  }));
+
+  const seeds: SeedEntry[] = (declared.seeds ?? []).map((s) => ({
+    entityName: s.entityName,
+    data: s.data,
+    filePath: '',
+  }));
+
+  return {
+    name,
+    source: { path: '', package: `${scope}/${name}` },
+    providers,
+    entities,
+    handlers,
+    presenters,
+    collectors,
+    seeds,
+    ...(declared.surfaces ? { surfaces: declared.surfaces } : {}),
+  };
+}