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

package/src/prefab/mirror.ts

@@ -1,32 +1,10 @@
-import { FieldSet, Lifecycle, type EntityConstructor, type Fields, type ValidationResult } from '@fougere/schema';
-import type { EntityOrm } from '../orm.js';
+import { Lifecycle, type EntityConstructor, type Fields } from '@fougere/schema';
+import type { Storage } from '../storage.js';
 
-/**
- * A paginated local copy of a source that cannot be queried directly.
- *
- * The shape must contain an `updated()` field used as a high-water mark. Subclasses
- * implement `pull`; `refresh` validates and upserts each returned page.
- *
- * ```ts
- * export default class PartnerCatalog extends Mirror(BookCard) {
- *   constructor(orm: EntityOrm<BookCard>, private catalog: Facade<CatalogHandler>) {
- *     super(orm);
- *   }
- *
- *   async *pull(since?: Date) {
- *     for (let page = 0; page !== null;) {
- *       const body = await fetch(`${api}?page=${page}&since=${since?.toISOString() ?? ''}`);
- *       const { items, next } = await body.json();
- *       yield items.map(toCard);
- *       page = next;
- *     }
- *   }
- * }
- * ```
- */
+/** A paginated local copy of a source that cannot be queried directly. */
 /** What one refresh did — enough to log it, and to decide whether to run again. */
 export interface Refreshed {
-  /** Rows written, counting a replaced row once. */
+  /** Instances written, counting a replaced one once. */
   written: number;
   /** The age the pull was asked to start from — absent on the first ever run. */
   since?: Date;
@@ -36,7 +14,7 @@ export interface Refreshed {
 
 export interface MirrorOf<T> {
   /** The copy's own storage — where a page lands, and where its age is read. */
-  orm: EntityOrm<T>;
+  storage: Storage<T>;
   /** Pages of rows to write. The one thing a mirror's author supplies. */
   pull(since?: Date): AsyncIterable<Partial<T>[]>;
   /** Run one pass: read the high-water mark, pull from there, write each page. */
@@ -46,7 +24,7 @@ export interface MirrorOf<T> {
 }
 
 export interface MirrorConstructor<T> {
-  new (orm: EntityOrm<T>): MirrorOf<T>;
+  new (storage: Storage<T>): MirrorOf<T>;
   readonly __entity: unknown;
 }
 
@@ -66,13 +44,13 @@ export function Mirror<E extends EntityConstructor>(shape: E): MirrorConstructor
   abstract class MirrorBase implements MirrorOf<T> {
     static readonly __entity = shape;
 
-    constructor(public orm: EntityOrm<T>) {}
+    constructor(public storage: Storage<T>) {}
 
     abstract pull(since?: Date): AsyncIterable<Partial<T>[]>;
 
     /** The freshest persisted stamp; no process-local freshness state is kept. */
     async freshness(): Promise<Date | undefined> {
-      const [newest] = await this.orm.list({ orderBy: age, order: 'desc', limit: 1 });
+      const [newest] = await this.storage.list({ orderBy: age, order: 'desc', limit: 1 });
       const value = (newest as Record<string, unknown> | undefined)?.[age];
       return value instanceof Date ? value : undefined;
     }
@@ -84,7 +62,7 @@ export function Mirror<E extends EntityConstructor>(shape: E): MirrorConstructor
       // Preserve the source's page boundaries: one page becomes one upsert.
       for await (const page of this.pull(since)) {
         if (page.length === 0) continue;
-        written += await this.orm.upsertAll(judgePage(shape, page) as Partial<T>[]);
+        written += await this.storage.upsertAll(page);
       }
       return { written, since, ms: Date.now() - started };
     }
@@ -102,21 +80,3 @@ export function ageFieldOf(shape: unknown): string | undefined {
   }
   return undefined;
 }
-
-/** Validate and decode a page, naming a refused row by its declared primary field. */
-function judgePage<T>(shape: unknown, page: Partial<T>[]): Record<string, unknown>[] {
-  const judge = (shape as { validate?: (input: unknown) => ValidationResult<unknown> }).validate;
-  if (typeof judge !== 'function') return page as Record<string, unknown>[];
-
-  const name = (shape as { name?: string }).name ?? 'mirror';
-  const fields = (shape as { getFields?: () => Fields }).getFields?.();
-  const primary = fields ? FieldSet.of(fields).primary : undefined;
-  return page.map((row, index) => {
-    const verdict = judge.call(shape, row);
-    if (verdict.success) return verdict.data as Record<string, unknown>;
-    const key = primary === undefined ? undefined : (row as Record<string, unknown>)[primary];
-    const where = key !== undefined ? `row ${primary} ${JSON.stringify(key)}` : `row ${index} of this page`;
-    const why = verdict.errors.map((e) => `${e.path}: ${e.message}`).join(', ');
-    throw new Error(`${name} mirror refused ${where} — ${why}`);
-  });
-}

package/src/prefab/prefab.ts

@@ -1,20 +1,7 @@
 import type { EntityConstructor } from '@fougere/schema';
 import type { PresenterViews } from './presenter.js';
 
-/**
- * What a prefab class declares about ITSELF, at runtime.
- *
- * `Crud(Post)`, `Presenter(Post)`, `Repository(Post)`, `Collector(User)` and
- * `Mirror(BookCard)` all fabricate a class, and only the fabricator knows what it was
- * built on: the AST scan is workspace-only, so an INSTALLED prefab resolves to nothing
- * and a statement written in source would be lost. Hence a runtime marker — the same
- * reason `__ops` exists.
- *
- * It was three spellings for one statement: `static __entity` on three of the five, a
- * private `Symbol.for('fougere:x_target')` on the other two, and BOTH on `Repository`
- * and `Mirror` — the same class recording its subject twice, under two names, with two
- * readers that could disagree. A mark that answers one question answers it once.
- */
+/** What a prefab class declares about ITSELF, at runtime. */
 interface Prefab {
   /** The shape this class was built on. `Mirror` calls it a shape; it is the same slot. */
   readonly __entity?: EntityConstructor;
@@ -24,13 +11,7 @@ interface Prefab {
   readonly __output?: EntityConstructor;
 }
 
-/**
- * The shape a prefab was built on, or `undefined` when the class is not one.
- *
- * A plain property read: JavaScript walks a constructor's own prototype chain, so a
- * subclass of a prefab answers what its base recorded. Three of the five accessors this
- * replaces walked that chain by hand, and two did not — one question, two mechanisms.
- */
+/** The shape a prefab was built on, or `undefined` when the class is not one. */
 export function targetOf(ctor: unknown): EntityConstructor | undefined {
   return (ctor as Prefab | undefined)?.__entity;
 }

package/src/prefab/presenter.ts

@@ -1,26 +1,4 @@
-/**
- * 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);
- *   }
- * }
- * ```
- */
+/** Presenter(Entity) — enriches an entity's output with computed fields. */
 
 import { upperFirst, type EntityConstructor } from '@fougere/schema';
 
@@ -30,19 +8,7 @@ import { upperFirst, type EntityConstructor } from '@fougere/schema';
  */
 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.
- */
+/** `Presenter(Order, { items. */
 export function Presenter<E extends EntityConstructor>(entity: E, views?: PresenterViews) {
   class PresenterBase {
     static readonly __entity = entity;

package/src/prefab/repository.ts

@@ -1,95 +1,32 @@
 import { upperFirst, type EntityConstructor } from '@fougere/schema';
-import type { EntityOrm, ListOptions, ListResult, SelectOption } from '../orm.js';
+import type { Storage, ListOptions, ListResult, SelectOption } from '../storage.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.
- */
+/** Repository(…entities) — who owns an entity's storage, and where its questions are named. */
 
 /**
- * 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.
+ * The shape a repository of ONE entity has — the port itself, plus whatever the subclass names on
+ * top.
  */
-export type RepositoryOf<T> = EntityOrm<T>;
+export type RepositoryOf<T> = Storage<T>;
 
 /** The single-entity form: the port, plus whatever the subclass names. */
 export interface RepositoryConstructor<T> {
-  new (orm: EntityOrm<T>): EntityOrm<T>;
+  new (storage: Storage<T>): Storage<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.
- */
+/** What an aggregate's subclass sees. */
 declare abstract class AggregateShape<E extends readonly EntityConstructor[]> {
-  protected orms: { [K in keyof E]: EntityOrm<InstanceType<E[K]>> };
+  protected storages: { [K in keyof E]: Storage<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]>> };
+  { [K in keyof E]: Storage<InstanceType<E[K]>> };
 
 export type AggregateConstructor<E extends readonly EntityConstructor[]> =
-  (new (...orms: unknown[]) => AggregateShape<E>) & {
+  (new (...storages: unknown[]) => AggregateShape<E>) & {
     readonly __entity: unknown;
     /** The entities this class owns. Present from two on — an owner of one owns nothing. */
     readonly __owns: E;
@@ -103,51 +40,43 @@ 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.
- */
+/** The port forwarded, member by member. */
 function one<E extends EntityConstructor>(entity: E): RepositoryConstructor<InstanceType<E>> {
   type T = InstanceType<E>;
 
-  class RepositoryBase implements EntityOrm<T> {
+  class RepositoryBase implements Storage<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; }
+    constructor(protected storage: Storage<T>) {}
+
+    list(options?: ListOptions & SelectOption): Promise<ListResult<T>> { return this.storage.list(options); }
+    findById(id: string, options?: SelectOption) { return this.storage.findById(id, options); }
+    findBy(criteria: Partial<T> | Record<string, unknown>, options?: SelectOption) { return this.storage.findBy(criteria, options); }
+    findAllBy(criteria: Partial<T> | Record<string, unknown>, options?: SelectOption) { return this.storage.findAllBy(criteria, options); }
+    findByKeys(ids: readonly string[], options?: SelectOption) { return this.storage.findByKeys(ids, options); }
+    findAllByKeys(field: string, keys: readonly string[], options?: SelectOption) { return this.storage.findAllByKeys(field, keys, options); }
+    create(input: Partial<T>, options?: SelectOption) { return this.storage.create(input, options); }
+    upsert(input: Partial<T>, options?: SelectOption) { return this.storage.upsert(input, options); }
+    upsertAll(inputs: readonly Partial<T>[], options?: SelectOption) { return this.storage.upsertAll(inputs, options); }
+    update(id: string, input: Partial<T>, options?: SelectOption) { return this.storage.update(id, input, options); }
+    delete(id: string) { return this.storage.delete(id); }
+    output(schema: SchemaView) { return this.storage.output(schema); }
+    get client(): unknown { return this.storage.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.
- */
+/** The aggregate. */
 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>;
+    protected storages: AggregateOf<E>;
 
-    constructor(...orms: unknown[]) {
-      this.orms = orms.slice(0, entities.length) as AggregateOf<E>;
+    constructor(...storages: unknown[]) {
+      this.storages = storages.slice(0, entities.length) as AggregateOf<E>;
     }
   }
 
@@ -159,12 +88,7 @@ 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.
- */
+/** The entities a class owns — empty for anything that is not an aggregate. */
 export function ownedBy(ctor: unknown): readonly EntityConstructor[] {
   return (ctor as { __owns?: readonly EntityConstructor[] } | undefined)?.__owns ?? [];
 }

package/src/scan/adapters.ts

@@ -0,0 +1,32 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+/** Which adapters a PROJECT could load, read off its dependencies. */
+const ADAPTER_PACKAGE = /^@fougere\/adapter-(.+)$/;
+
+/** The adapter names this project depends on — empty when it has no package.json to read. */
+export async function adaptersOf(root: string): Promise<string[]> {
+  const manifest = await read(join(root, 'package.json'));
+  if (!manifest) return [];
+
+  const declared = { ...manifest.dependencies, ...manifest.devDependencies };
+
+  return Object.keys(declared)
+    .map((name) => ADAPTER_PACKAGE.exec(name)?.[1])
+    .filter((name): name is string => name !== undefined);
+}
+
+async function read(path: string): Promise<Manifest | undefined> {
+  try {
+    return JSON.parse(await readFile(path, 'utf8')) as Manifest;
+  } catch {
+    // No manifest, or one that is not JSON. Either way this cannot validate a name, and
+    // reporting every `adapters:` key as unknown would be worse than saying nothing.
+    return undefined;
+  }
+}
+
+interface Manifest {
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+}

package/src/scan/bundling.ts

@@ -1,15 +1,4 @@
-/**
- * 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.
- */
+/** What a Fougere boot loads at RUNTIME, so a bundler must leave it alone. */
 export const RUNTIME_PACKAGES: readonly string[] = [
   '@fougere/app',
   '@fougere/core',

package/src/scan/conventions.ts

@@ -1,19 +1,7 @@
-/**
- * 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.
- */
+/** The names the scan READS instead of deriving them. */
 
 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.
-   */
+  /** The scope a frond's package name carries — `@fronds/blog`. */
   scope: string;
   /** The directory holding fronds, below the project root. */
   fronds: string;
@@ -31,12 +19,7 @@ export interface Conventions {
   };
 }
 
-/**
- * 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.
- */
+/** What a project means when it declares nothing — the convention itself. */
 export const DEFAULT_CONVENTIONS: Conventions = {
   scope: '@fronds',
   fronds: 'fronds',
@@ -59,13 +42,7 @@ export type ConventionsInput = {
   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.
- */
+/** The convention, with a project's exceptions folded in. */
 export function resolveConventions(input?: ConventionsInput): Conventions {
   return {
     scope: input?.scope ?? DEFAULT_CONVENTIONS.scope,
@@ -79,23 +56,12 @@ 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.
- */
+/** Directories whose classes register as providers — two spellings, one behaviour. */
 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`.
- */
+/** The frond vocabulary — every directory the scan reads. */
 export function frondDirsOf(conventions: Conventions): string[] {
   const { entities, handlers, presenters, collectors, seeds, versions } = conventions.dirs;
   return [...new Set([

package/src/scan/emit.ts

@@ -1,25 +1,8 @@
-/**
- * The scan, written down as a module — what `createApp` is handed where there is no disk.
- *
- * It RE-RESOLVES NOTHING. By the time this runs the scan has already decided what every
- * slot holds, and `resolveSchema` put the entity's own class in `contract.output` — the
- * very object `EntityEntry.entityClass` holds. So the emitter keeps a table from object
- * to import alias and writes the alias. Identity is preserved because it is the same
- * object that becomes the same import, which is what three call sites depend on
- * (`adapter/graphql`'s `view === entity.entityClass` and its WeakMap, and `bootstrap`'s
- * `outputSchema !== entity.entityClass`). An emitter that re-resolved instead would build
- * a second class for `Post` and those three would silently take the other branch.
- *
- * Measured on three real projects: every live reference is either a class the descriptor
- * already names by `filePath`, a named export of the file that declared the signature, or
- * `Partial<X>` — the one derivation `resolveSchema` fabricates.
- */
+/** The scan, written down as a module — what `createApp` is handed where there is no disk. */
 import { dirname, relative } from 'node:path';
 import { ANONYMOUS_SCHEMA_NAME, Card, type SchemaView } from '@fougere/schema';
-import type {
-  ScanResult, FrondDescriptor, EntityEntry, HandlerEntry,
-  PresenterEntry, CollectorEntry, ProviderEntry, SeedEntry,
-} from './frond.js';
+import type { FrondDescriptor, EntityEntry, HandlerEntry, PresenterEntry, CollectorEntry, ProviderEntry, SeedEntry } from '../descriptor/frond.js';
+import type { ScanResult } from './result.js';
 import type { OperationContract } from '../wire/operation.js';
 
 export interface EmitOptions {
@@ -34,14 +17,7 @@ type Live = object;
 /** Is a TypeScript compiler going to read this module? Its name is the only thing that says. */
 const isTypeScript = (outFile: string): boolean => /\.tsx?$/.test(outFile);
 
-/**
- * A source file becomes a specifier its reader can follow — and the two readers differ.
- *
- * A `.ts` destination is compiled by tsc under Node16 resolution, which spells a
- * TypeScript source with `.js`. A `.mjs` destination is read by a bundler, which resolves
- * the path AS IT IS ON DISK — measured, Nitro's rollup refused `Post.seed.js` because no
- * such file exists. One rule, read off the destination, exactly like the type annotation.
- */
+/** A source file becomes a specifier its reader can follow — and the two readers differ. */
 function specifierOf(filePath: string, outFile: string): string {
   const path = relative(dirname(outFile), filePath);
   const rel = isTypeScript(outFile) ? path.replace(/\.tsx?$/, '.js') : path;
@@ -83,15 +59,7 @@ class Imports {
   render(): string { return this.lines.join('\n'); }
 }
 
-/**
- * What a schema slot becomes in the generated module.
- *
- * Three answers, and the third is the only rule: a class already imported is its alias; a
- * named export of the file that declared the signature is imported by its own name — it
- * IS exported there, because that is where `resolveSchema` found it; and an anonymous
- * schema is `Partial<X>`, the one derivation `resolveSchema` builds, so it is written as
- * the derivation rather than as a value.
- */
+/** What a schema slot becomes in the generated module. */
 function schemaRef(schema: SchemaView | undefined, declaredIn: string, imports: Imports): string | undefined {
   if (!schema) return undefined;
   const known = imports.aliasOf(schema as Live);
@@ -180,11 +148,7 @@ function frondOf(f: FrondDescriptor, imports: Imports): string {
   ].filter(Boolean).join('\n');
 }
 
-/**
- * Write a scan down. The result is a TypeScript module whose only imports are the classes
- * the scan found — static, so a bundler traces them — and whose only value is the
- * descriptor `createApp` asks for.
- */
+/** Write a scan down. */
 export function emitScan(result: ScanResult, options: EmitOptions): string {
   const imports = new Imports(options.outFile);
   const core = options.core ?? '@fougere/core';
@@ -222,7 +186,7 @@ import { Fronds } from '${core}';
 ${typed ? `import type { ScanResult } from '${core}';\n` : ''}${imports.render()}
 
 export const scan${typed ? ': ScanResult' : ''} = {
-  fronds: Fronds.scanned([
+  fronds: Fronds.hosting([
 ${fronds}
   ]),
   diagnostics: [${diagnostics.join(', ')}],