@fougere/core 0.2.0-alpha.2 → 0.4.0-alpha.0

package/dist/{scanner.js → scan/scanner.js}

@@ -1,34 +1,27 @@
 import { readdir, readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { join, dirname, basename, resolve as resolvePath } from 'node:path';
-import { pathToFileURL } from 'node:url';
 import { ANONYMOUS_SCHEMA_NAME } from '@fougere/schema';
-import { cardinalityOf } from './operation.js';
-import { parseAllHandlerMethods, parsePresenterMethods, parseConstructorParams } from './handler-parser.js';
-import { hashFile, getCached, setCached, flushCache, setCacheRoot } from './scan-cache.js';
-import { loadFrondConfig } from './frond-config.js';
-import { emitKeyOf } from './emit.js';
-import { getPresenterTarget, getPresenterFields, getPresenterViews } from './presenter.js';
-import { getRepositoryTarget } from './repository.js';
-import { ormKeyOf } from './orm.js';
-import { getCollectorTarget } from './collector.js';
-const defaultLoader = async (filePath) => await import(pathToFileURL(filePath).href);
-let activeLoader = defaultLoader;
-/** Override the module loader used by the scanner (e.g. for jiti/tsx support). */
-export function setModuleLoader(loader) {
-    activeLoader = loader;
-}
-/** Used by config-loader to load fougere.config.ts via the same TS-aware loader. */
-export function getModuleLoader() {
-    return activeLoader;
-}
+import { cardinalityOf } from '../wire/operation.js';
+import { computeBindingPlan } from '../boot/binding.js';
+import { parseAllHandlerMethods, parsePresenterMethods, parseConstructorParams, resetTypePrograms, seedTypeProgram, } from './handler-parser.js';
+import { loadFrondConfig } from '../frond-config.js';
+import { emitKeyOf } from '../emit.js';
+import { getPresenterFields } from '../prefab/presenter.js';
+import { ormKeyOf, togetherKeyOf } from '../orm.js';
+import { targetOf, viewsOf, outputOf } from '../prefab/prefab.js';
+import { ownedBy, repositoryKeyOf } from '../prefab/repository.js';
+import { lowerFirst } from '@fougere/schema';
+import { Fronds } from './Fronds.js';
+import { getModuleLoader } from '../loader.js';
+import { DEFAULT_CONVENTIONS, resolveConventions, frondPackage, providerDirsOf, frondDirsOf, } from './conventions.js';
 // FS
 /**
  * What this scan run could not do. Reset by {@link scanProject}, which owns a run.
  *
- * Module-scoped like the loader and the cache root above: the scanner already has
- * a notion of "the current run", and threading a collector through twenty call
- * sites would state the same thing more loudly and less clearly.
+ * Module-scoped like the loader and the cache root above: the scanner already has a
+ * notion of "the current run". Three sites record — measured — so a per-run object
+ * would carry twenty methods to spare one line of reset.
  */
 let diagnostics = [];
 function record(d) {
@@ -72,7 +65,7 @@ async function files(path) {
 }
 // Module
 async function loadModule(filePath) {
-    return await activeLoader(filePath);
+    return await getModuleLoader()(filePath);
 }
 async function loadDefault(filePath) {
     const mod = await loadModule(filePath);
@@ -98,21 +91,6 @@ function findWorkspaceRoot(from) {
     }
     return resolvePath(from); // fallback: use project root itself
 }
-// Convention
-/** Directories whose classes register as providers — two spellings, one behaviour. */
-const PROVIDER_DIRS = ['services', 'repositories'];
-/**
- * The frond vocabulary — every directory {@link scanFrond} reads. A frond directory says
- * nothing else, which is why this list is what a reader needs to bound one: 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 const FROND_DIRS = [
-    'entities', 'handlers', 'presenters', 'collectors', 'seeds', ...PROVIDER_DIRS,
-];
-export { toRegistrationName } from './contract.js';
-import { toRegistrationName } from './contract.js';
 /**
  * Strip the 'Handler' suffix → the name the handler answers to. 'PostHandler' → 'post'.
  *
@@ -122,7 +100,7 @@ import { toRegistrationName } from './contract.js';
  */
 function toAddress(className) {
     const base = className.endsWith('Handler') ? className.slice(0, -7) : className;
-    return base[0].toLowerCase() + base.slice(1);
+    return lowerFirst(base);
 }
 // Scan
 /**
@@ -146,53 +124,73 @@ function depKeyOf(type) {
     // façade or a doublure, which is what makes the topology invisible from a signature.
     const facadeOf = type.name === 'Facade' ? type.generics?.[0]?.name : undefined;
     if (facadeOf)
-        return toRegistrationName(facadeOf);
+        return lowerFirst(facadeOf);
     // `Emit<PostPublished>` — the third port, and the only one that names a SUBJECT rather
     // than an interlocutor. Read like the other two: the type names what arrives, here a
     // function that announces. Who receives it is not in the signature and never will be.
     const factOf = type.name === 'Emit' ? type.generics?.[0]?.name : undefined;
     if (factOf)
         return emitKeyOf(factOf);
+    // `Together<[Account, Ledger], [RateMirror]>` — the fifth reading, and the only one whose
+    // argument is a SET rather than one subject. The AST hands each tuple back as a single
+    // string, so they are split here, where every other question of "how was it written" lives.
+    const frame = type.name === 'Together' ? type.generics?.[0]?.name : undefined;
+    if (frame)
+        return togetherKeyOf(tupleMembers(frame), tupleMembers(type.generics?.[1]?.name ?? ''));
+    // `RepositoryOf<Post>` — what an author writes when no repository file exists. The dual
+    // of the line below: one names the port, the other the holder, and both resolve to a key
+    // rather than to a class the author would have to invent.
+    const held = type.name === 'RepositoryOf' ? type.generics?.[0]?.name : undefined;
+    if (held)
+        return repositoryKeyOf(held);
     const target = type.name === 'EntityOrm' ? type.generics?.[0]?.name : undefined;
     if (!target)
         return type.name;
     return ormKeyOf(target);
 }
-/** Cached parseConstructorParams — skips TS loading when cache is warm. */
-async function cachedCtorParams(filePath) {
-    const hash = hashFile(filePath);
-    const key = filePath + ':ctor';
-    const cached = getCached(key, hash);
-    if (cached)
-        return cached;
-    const params = await parseConstructorParams(filePath);
-    setCached(key, hash, params);
-    return params;
-}
-/** Cached parsePresenterMethods — skips TS loading when cache is warm. */
-async function cachedPresenterMethods(filePath) {
-    const hash = hashFile(filePath);
-    const key = filePath + ':presenter';
-    const cached = getCached(key, hash);
-    if (cached)
-        return cached;
-    const methods = await parsePresenterMethods(filePath);
-    setCached(key, hash, methods);
-    return methods;
+/**
+ * `'[Account, Ledger]'` → `['Account', 'Ledger']`.
+ *
+ * The tuple was chosen over the variadic form the parser reads more cleanly, because the
+ * variadic one costs arities-with-defaults and a `never` filter on the TypeScript side
+ * while the tuple maps to `[EntityOrm<Account>, EntityOrm<Ledger>]` in one line. The
+ * parser does not get to decide alone; this split is what that choice costs.
+ */
+function tupleMembers(raw) {
+    return raw.replace(/^\[|\]$/g, '').split(',').map((member) => member.trim()).filter(Boolean);
 }
+/**
+ * These readings are semantic: an unchanged file can mean something different after an
+ * imported alias changes. The parser's TypeScript Program is the cache for one scan; a
+ * cache keyed only by this file's bytes would be unsound.
+ */
+const ctorParamsOf = (filePath) => parseConstructorParams(filePath);
+const presenterMethodsOf = (filePath) => parsePresenterMethods(filePath);
+const handlerMethodsOf = (filePath, projectRoot) => parseAllHandlerMethods(filePath, projectRoot);
 async function toProvider(filePath) {
     const ctor = await loadClass(filePath);
-    const params = await cachedCtorParams(filePath);
+    const params = await ctorParamsOf(filePath);
     const deps = params.map((p) => depKeyOf(p.type));
-    // A repository inherits its constructor from `Repository(Entity)`, so the file
-    // declares none and the scan reads no parameter. The mixin knows which entity it
-    // was built for and says so at runtime — same escape as `Crud.__ops`, and the same
-    // reason: what a prefab fabricates, only the prefab can describe.
-    const target = getRepositoryTarget(ctor);
-    if (target && deps.length === 0) {
-        deps.push(`${toRegistrationName(target.name).replace(/^./, (c) => c.toUpperCase())}Orm`);
+    // A repository inherits its constructor from `Repository(…)`, so the file declares none
+    // and the scan reads no parameter. The mixin knows what it was built for and says so at
+    // runtime — same escape as `Crud.__ops`, and the same reason: what a prefab fabricates,
+    // only the prefab can describe.
+    //
+    // An AGGREGATE owns several, and its base takes them in the declared order. It is handed
+    // no frame: the boundary and the unit of work are two statements, and a frame is ASKED FOR
+    // like anywhere else — see `prefab/repository.ts`.
+    const owned = ownedBy(ctor);
+    const target = targetOf(ctor);
+    if (owned.length > 1 && deps.length === 0) {
+        deps.push(...owned.map((entity) => ormKeyOf(lowerFirst(entity.name))));
     }
-    return { name: toRegistrationName(ctor.name), ctor, deps, filePath };
+    else if (target && deps.length === 0) {
+        deps.push(ormKeyOf(lowerFirst(target.name)));
+    }
+    // No `name` beside `ctor`: a provider registers under `ctor.name`, which is what
+    // `depKeyOf` returns since it reads the type as written. The camelCase field that
+    // used to sit here called itself the registration key and was one nowhere.
+    return { ctor, deps, filePath };
 }
 async function toEntityEntry(filePath) {
     const exported = await loadDefault(filePath);
@@ -206,7 +204,7 @@ async function toEntityEntry(filePath) {
     const declaredName = runtimeName && runtimeName !== ANONYMOUS_SCHEMA_NAME
         ? runtimeName
         : basename(filePath).replace(/\.[^.]+$/, '');
-    const name = toRegistrationName(declaredName);
+    const name = lowerFirst(declaredName);
     return { name, entityClass: exported, filePath };
 }
 /**
@@ -214,8 +212,8 @@ async function toEntityEntry(filePath) {
  * Handles arrays, generics (uses base name), and simple references.
  */
 function resolveSchema(type, moduleExports) {
-    // For arrays, resolve the element type
-    const name = type.array ? type.name : type.name;
+    // An array's element type IS `type.name` — the arity rides beside it, so nothing has
+    // to be unwrapped here.
     // For generics like Pagination<Post>, also check inner types
     if (type.generics) {
         for (const g of type.generics) {
@@ -231,7 +229,7 @@ function resolveSchema(type, moduleExports) {
             }
         }
     }
-    const resolved = moduleExports[name];
+    const resolved = moduleExports[type.name];
     if (resolved && typeof resolved === 'function' && 'getFields' in resolved) {
         return resolved;
     }
@@ -243,20 +241,11 @@ function resolveSchema(type, moduleExports) {
  * Resolves schemas for all params (not just the first) and stores
  * full signatures for the binding algorithm.
  */
-async function inferOperations(filePath, moduleExports, projectRoot) {
+async function inferOperations(filePath, handlerName, moduleExports, collectorTypeNames, explicitInputs, declared, projectRoot) {
     const map = new Map();
     let parsed;
     try {
-        const hash = hashFile(filePath);
-        const cacheKey = filePath + ':all' + (projectRoot ? ':inherited' : '');
-        const cached = getCached(cacheKey, hash);
-        if (cached) {
-            parsed = cached;
-        }
-        else {
-            parsed = await parseAllHandlerMethods(filePath, projectRoot);
-            setCached(cacheKey, hash, parsed);
-        }
+        parsed = await handlerMethodsOf(filePath, projectRoot);
     }
     catch (cause) {
         // The handler still gets a façade — its methods exist at runtime — but with no
@@ -302,11 +291,34 @@ async function inferOperations(filePath, moduleExports, projectRoot) {
             signature: method,
             ...(method.description && { description: method.description }),
         };
-        // Resolve schemas for all params
-        for (const param of method.params) {
+        // A convention may omit a declaration only when it has one answer. Only values the
+        // caller supplies through the body are candidates: a schema-typed collector, fact or
+        // context parameter is not input merely because it names an entity. The old loop
+        // ignored provenance and assigned the first schema it met, so swapping two parameters
+        // silently changed the contract the façade used to judge the request body.
+        const binding = computeBindingPlan(method.params, collectorTypeNames);
+        const candidates = method.params.flatMap((param, index) => {
+            if (binding[index]?.source.kind !== 'body')
+                return [];
             const schema = resolveSchema(param.type, moduleExports);
-            if (schema && !meta.input)
-                meta.input = schema;
+            return schema ? [{ param, schema }] : [];
+        });
+        if (candidates.length === 1) {
+            meta.input = candidates[0].schema;
+        }
+        else if (candidates.length > 1
+            && declared[method.name]?.input === undefined
+            && !explicitInputs.has(method.name)) {
+            const subject = `${handlerName}.${method.name}`;
+            record({
+                severity: 'blocking',
+                code: 'input-contract-ambiguous',
+                filePath,
+                subject,
+                message: `Cannot infer the input contract for ${subject}: ${candidates.length} entity `
+                    + `candidates — ${candidates.map(({ param }) => `${param.name}: ${param.type.raw}`).join('; ')}. `
+                    + `Declare operations.${method.name}.input in frond.config.ts.`,
+            });
         }
         if (method.returnType) {
             meta.output = resolveSchema(method.returnType, moduleExports);
@@ -317,7 +329,7 @@ async function inferOperations(filePath, moduleExports, projectRoot) {
     }
     return map;
 }
-async function toHandlerEntry(filePath, entityByClassName, projectRoot, surface) {
+async function toHandlerEntry(filePath, entityByClassName, collectorTypeNames, explicitInputs, projectRoot, surface) {
     const mod = await loadModule(filePath);
     const ctor = mod.default;
     if (typeof ctor !== 'function' || !ctor.prototype)
@@ -330,15 +342,20 @@ async function toHandlerEntry(filePath, entityByClassName, projectRoot, surface)
             augmented[className] = entityClass;
     }
     const address = toAddress(ctor.name);
-    const operations = await inferOperations(filePath, augmented, projectRoot);
-    const ctorParams = await cachedCtorParams(filePath);
+    const declaredOps = ctor.__ops ?? {};
+    const operations = await inferOperations(filePath, ctor.name, augmented, collectorTypeNames, explicitInputs, declaredOps, projectRoot);
+    const ctorParams = await ctorParamsOf(filePath);
     const deps = ctorParams.map((p) => depKeyOf(p.type));
     // Read output override from Crud(Entity, Output) — static __output property
-    const __entity = ctor.__entity;
-    const __output = ctor.__output;
-    const outputOverride = __output && __entity && __output !== __entity ? __output : undefined;
+    // A handler-wide view, when it is not simply the entity — the two are compared by
+    // identity, which is why both slots are read through the same door.
+    const subject = targetOf(ctor);
+    const declared = outputOf(ctor);
+    const outputOverride = declared && subject && declared !== subject
+        ? declared
+        : undefined;
     return {
-        name: toRegistrationName(ctor.name),
+        name: lowerFirst(ctor.name),
         address,
         ctor: ctor,
         operations,
@@ -351,7 +368,7 @@ async function toHandlerEntry(filePath, entityByClassName, projectRoot, surface)
 /** Strip '.seed' suffix → entity name. 'Author.seed.ts' → 'author'. */
 function toSeedEntityName(fileName) {
     const base = fileName.replace(/\.seed\.(ts|js)$/, '').replace(/\.(ts|js)$/, '');
-    return base[0].toLowerCase() + base.slice(1);
+    return lowerFirst(base);
 }
 async function toSeedEntry(filePath) {
     const data = await loadDefault(filePath);
@@ -363,17 +380,17 @@ async function toSeedEntry(filePath) {
 }
 async function toPresenterEntry(filePath) {
     const ctor = await loadClass(filePath);
-    const target = getPresenterTarget(ctor);
+    const target = targetOf(ctor);
     if (!target)
         return null;
-    const entityName = toRegistrationName(target.name);
+    const entityName = lowerFirst(target.name);
     const fields = getPresenterFields(ctor);
-    const presenterParams = await cachedCtorParams(filePath);
+    const presenterParams = await ctorParamsOf(filePath);
     const deps = presenterParams.map((p) => depKeyOf(p.type));
     // Parse method return types from source
     let fieldMeta = [];
     try {
-        const parsed = await cachedPresenterMethods(filePath);
+        const parsed = await presenterMethodsOf(filePath);
         fieldMeta = parsed.map((m) => ({
             name: m.name,
             returnType: m.returnType?.name,
@@ -384,61 +401,83 @@ async function toPresenterEntry(filePath) {
             // Everything after the rows is bound like a handler's argument.
             params: m.params.slice(1),
         }));
+        // The rows parameter is stripped just above, and nothing used to check its SHAPE.
+        // A computed field receives the PAGE and answers one value per row, so a method
+        // written `items(order: Order)` compiles and dies at the first call with a 500
+        // (`expected 1 value(s) for 1 row(s), got 0`) — while the information sat here, at
+        // the scan. Every own method of a presenter IS a computed field
+        // (`getPresenterFields`), so there is no private helper to spare.
+        //
+        // An ERROR at boot, not a refusal: a `blocking` scan diagnostic is logged and the
+        // app still starts (`bootstrap.ts`, and the comment above that loop says why). Making
+        // it refuse means deciding that a declaration which cannot work is an unresolved
+        // CONTRACT — the one thing that does stop the boot — and that is a decision, not a
+        // severity.
+        for (const method of parsed) {
+            const rows = method.params[0];
+            if (rows && rows.type.array === true)
+                continue;
+            record({
+                severity: 'blocking',
+                code: 'presenter-field-not-page',
+                filePath,
+                subject: `${ctor.name ?? 'Presenter'}.${method.name}`,
+                message: `${method.name}(${rows ? `${rows.name}: ${rows.type.raw}` : ''}) is a computed `
+                    + `field, so it receives the PAGE and must answer one value per row. Declare `
+                    + `${method.name}(${rows?.name ?? 'rows'}: ${target.name ?? 'Entity'}[]) `
+                    + `and return an array of the same length.`,
+            });
+        }
     }
     catch { /* parse failure — fall back to untyped */ }
     // Declared at runtime on the class, so it survives a scan that resolved nothing.
-    return { entityName, ctor, fields, fieldMeta, views: getPresenterViews(ctor), deps, filePath };
+    return { entityName, ctor, fields, fieldMeta, views: viewsOf(ctor), deps, filePath };
 }
 async function toCollectorEntry(filePath) {
     const ctor = await loadClass(filePath);
-    const target = getCollectorTarget(ctor);
+    const target = targetOf(ctor);
     if (!target)
         return null;
-    const entityName = toRegistrationName(target.name);
-    const collectorParams = await cachedCtorParams(filePath);
+    // The target's NAME and nothing else — a collector reads no fields, so the class it
+    // was built on needs no schema.
+    const typeName = lowerFirst(target.name);
+    const collectorParams = await ctorParamsOf(filePath);
     const deps = collectorParams.map((p) => depKeyOf(p.type));
-    return { entityName, ctor, deps, filePath };
+    return { typeName, ctor, deps, filePath };
 }
-async function scanFrond(frondPath, name, source, projectRoot) {
-    const providers = [];
-    const entities = [];
-    const handlers = [];
-    const presenters = [];
-    const collectors = [];
-    const seeds = [];
-    // Scan services/ and repositories/ — both land in the same provider list.
-    for (const dir of PROVIDER_DIRS) {
-        const paths = await files(join(frondPath, dir));
-        providers.push(...await Promise.all(paths.map((f) => toProvider(f))));
-    }
-    // Scan entities/
-    const entityPaths = await files(join(frondPath, 'entities'));
-    const entityEntries = await Promise.all(entityPaths.map((f) => toEntityEntry(f)));
-    entities.push(...entityEntries.filter((e) => e !== null));
-    // Build entity class map for schema resolution in handlers (T → entity class)
+async function scanFrond(frondPath, name, source, conventions, projectRoot) {
+    const { entities: entitiesDir, handlers: handlersDir, presenters: presentersDir, collectors: collectorsDir, seeds: seedsDir, } = conventions.dirs;
+    /**
+     * A convention directory, read by whoever knows the shape it holds.
+     *
+     * The same three lines were written six times — list, read in parallel, drop what the
+     * reader refused — which is what made `handlers/` quietly special: it grew a second
+     * pass for its surfaces and nothing else could.
+     */
+    const collect = async (dir, read) => {
+        const entries = await Promise.all((await files(join(frondPath, dir))).map(read));
+        return entries.filter((entry) => entry !== null);
+    };
+    // services/ and repositories/ — two spellings, one provider list.
+    const providers = (await Promise.all(providerDirsOf(conventions).map((dir) => collect(dir, toProvider)))).flat();
+    const entities = await collect(entitiesDir, toEntityEntry);
+    const collectors = await collect(collectorsDir, toCollectorEntry);
+    const collectorTypeNames = new Set(collectors.map((collector) => collector.typeName));
+    const frondConfig = await loadFrondConfig(frondPath);
+    const explicitInputs = new Set(Object.entries(frondConfig?.operations ?? {})
+        .filter(([, contract]) => contract.input !== undefined)
+        .map(([operation]) => operation));
+    // Handlers resolve `T` against the entities, so those come first.
     const entityByClassName = new Map(entities.map((e) => [e.entityClass.name, e.entityClass]));
-    // Scan handlers/ (root = default surface, subdirectories = named surfaces)
-    const handlerPaths = await files(join(frondPath, 'handlers'));
-    handlers.push(...await Promise.all(handlerPaths.map((f) => toHandlerEntry(f, entityByClassName, projectRoot))));
-    const surfaceDirs = await dirs(join(frondPath, 'handlers'));
-    for (const surfaceName of surfaceDirs) {
-        const surfacePaths = await files(join(frondPath, 'handlers', surfaceName));
-        handlers.push(...await Promise.all(surfacePaths.map((f) => toHandlerEntry(f, entityByClassName, projectRoot, surfaceName))));
+    const handlers = await collect(handlersDir, (f) => toHandlerEntry(f, entityByClassName, collectorTypeNames, explicitInputs, projectRoot));
+    // A subdirectory of handlers/ is a named surface — the one directory whose CHILDREN
+    // are part of the convention too.
+    for (const surface of await dirs(join(frondPath, handlersDir))) {
+        handlers.push(...await collect(join(handlersDir, surface), (f) => toHandlerEntry(f, entityByClassName, collectorTypeNames, explicitInputs, projectRoot, surface)));
     }
-    // Scan presenters/
-    const presenterPaths = await files(join(frondPath, 'presenters'));
-    const presenterEntries = await Promise.all(presenterPaths.map((f) => toPresenterEntry(f)));
-    presenters.push(...presenterEntries.filter((p) => p !== null));
-    // Scan collectors/
-    const collectorPaths = await files(join(frondPath, 'collectors'));
-    const collectorEntries = await Promise.all(collectorPaths.map((f) => toCollectorEntry(f)));
-    collectors.push(...collectorEntries.filter((c) => c !== null));
-    // Scan seeds/
-    const seedPaths = await files(join(frondPath, 'seeds'));
-    const seedEntries = await Promise.all(seedPaths.map((f) => toSeedEntry(f)));
-    seeds.push(...seedEntries.filter((s) => s !== null));
+    const presenters = await collect(presentersDir, toPresenterEntry);
+    const seeds = await collect(seedsDir, toSeedEntry);
     // Mark exposed entries: frond.config.ts takes precedence, then @expose decorator
-    const frondConfig = await loadFrondConfig(frondPath);
     if (frondConfig?.expose) {
         const exposeSet = new Set(frondConfig.expose);
         for (const e of entities) {
@@ -490,7 +529,7 @@ async function scanFrond(frondPath, name, source, projectRoot) {
  * Carrying the convention is what makes a frond; the key never marked anything and
  * nothing read it. It earns its keep as the one thing the directory cannot say: that
  * `fronds/blog-v2/` serves the frond still called `blog` — so a rename on disk does not
- * rename the entity keys, the `@frond/*` import or a `remotes:` entry.
+ * rename the entity keys, the `@fronds/*` import or a `remotes:` entry.
  */
 async function frondNameOf(frondPath, dirName) {
     try {
@@ -513,20 +552,20 @@ async function frondNameOf(frondPath, dirName) {
  * are ordinary top-level names in projects that never heard of Fougere, and a domain
  * without a single entity is not a domain.
  */
-async function rootFrondOf(root, workspaceRoot) {
-    if ((await files(join(root, 'entities'))).length === 0)
+async function rootFrondOf(root, workspaceRoot, conventions) {
+    if ((await files(join(root, conventions.dirs.entities))).length === 0)
         return null;
     const name = await frondNameOf(root, basename(resolvePath(root)));
-    return scanFrond(root, name, { path: root, package: `@frond/${name}` }, workspaceRoot);
+    return scanFrond(root, name, { path: root, package: frondPackage(name, conventions) }, conventions, workspaceRoot);
 }
 /**
- * `@frond/<name>` → the directory it names, for every frond of a project.
+ * `@fronds/<name>` → the directory it names, for every frond of a project.
  *
  * The framework states this convention — `FrondSource.package` has always spelled it, and
  * `fougere sync` writes it into a consumer's tsconfig — and until now its own reader could
  * not resolve it. The Nuxt module registered a Vite alias, so a `.vue` page could import
- * `@frond/blog/entities/Post`, while the SCAN loaded sources through a bare jiti: a frond
- * naming its neighbour got `Cannot find module '@frond/user/entities/User.js'`. So the one
+ * `@fronds/blog/entities/Post`, while the SCAN loaded sources through a bare jiti: a frond
+ * naming its neighbour got `Cannot find module '@fronds/user/entities/User.js'`. So the one
  * form that survives a split was the one form that did not run.
  *
  * Hand it to the module loader — `createJiti(url, { alias: await frondAliases(root) })` —
@@ -534,23 +573,23 @@ async function rootFrondOf(root, workspaceRoot) {
  * `package.json` read, no parsing: it is deliberately callable BEFORE the loader exists,
  * which is what makes the chicken-and-egg go away.
  */
-export async function frondAliases(root) {
-    const frondsDir = join(root, 'fronds');
+export async function frondAliases(root, conventions = DEFAULT_CONVENTIONS) {
+    const frondsDir = join(root, conventions.fronds);
     const aliases = {};
     // The root itself is a frond when it carries `entities/` — same rule as the scan.
-    if ((await files(join(root, 'entities'))).length > 0) {
-        aliases[`@frond/${await frondNameOf(root, basename(resolvePath(root)))}`] = resolvePath(root);
+    if ((await files(join(root, conventions.dirs.entities))).length > 0) {
+        aliases[frondPackage(await frondNameOf(root, basename(resolvePath(root))), conventions)] = resolvePath(root);
     }
     for (const dir of await dirs(frondsDir)) {
         const path = join(frondsDir, dir);
-        aliases[`@frond/${await frondNameOf(path, dir)}`] = resolvePath(path);
+        aliases[frondPackage(await frondNameOf(path, dir), conventions)] = resolvePath(path);
     }
     /**
      * A SYNCED frond answers to the same name.
      *
      * `fougere sync` writes `.fougere/remotes/<name>/` and registers it in `remotes.json`,
-     * which the Nuxt module already reads to alias `@frond/<name>`. Doing it here too is
-     * what makes the convention mean ONE thing: a consumer writes `@frond/blog/entities/Post`
+     * which the Nuxt module already reads to alias `@fronds/<name>`. Doing it here too is
+     * what makes the convention mean ONE thing: a consumer writes `@fronds/blog/entities/Post`
      * and never learns whether that frond is on this disk or was fetched from a card.
      *
      * A local frond wins a name collision — its source is the truth, a synced copy is a
@@ -559,9 +598,9 @@ export async function frondAliases(root) {
     try {
         const registry = JSON.parse(await readFile(join(root, '.fougere', 'remotes.json'), 'utf8'));
         for (const [name, entry] of Object.entries(registry)) {
-            if (typeof entry?.path !== 'string' || aliases[`@frond/${name}`])
+            if (typeof entry?.path !== 'string' || aliases[frondPackage(name, conventions)])
                 continue;
-            aliases[`@frond/${name}`] = resolvePath(entry.path);
+            aliases[frondPackage(name, conventions)] = resolvePath(entry.path);
         }
     }
     catch {
@@ -570,27 +609,33 @@ export async function frondAliases(root) {
     }
     return aliases;
 }
-export async function scanProject(root, filter) {
-    setCacheRoot(root);
+export async function scanProject(root, filter, conventionsInput) {
+    const conventions = resolveConventions(conventionsInput);
+    resetTypePrograms();
     // A run owns its findings: two scans in one process (a test suite, a watcher)
     // must not inherit each other's.
     diagnostics = [];
-    const frondsDir = join(root, 'fronds');
+    const frondsDir = join(root, conventions.fronds);
     const dirNames = await dirs(frondsDir);
     // Resolve workspace root (parent of packages/) for package import resolution
     // For monorepo: root is the project dir (e.g. demos/nuxt-blog), workspace root is the repo root
     const workspaceRoot = findWorkspaceRoot(root);
+    // One program for this run. Seeded here because the parser rebuilds on every root it
+    // has not seen, and a frond lives outside its project's tsconfig `include`. Both keys
+    // are seeded: heritage reads under the workspace root, a constructor under none.
+    const declarations = (await Promise.all([root, ...dirNames.map((dir) => join(frondsDir, dir))].flatMap((frondPath) => frondDirsOf(conventions).map((dir) => files(join(frondPath, dir)))))).flat();
+    await seedTypeProgram(declarations, workspaceRoot);
+    await seedTypeProgram(declarations);
     const [rootFrond, under] = await Promise.all([
-        rootFrondOf(root, workspaceRoot),
+        rootFrondOf(root, workspaceRoot, conventions),
         Promise.all(dirNames.map(async (dir) => {
             const name = await frondNameOf(join(frondsDir, dir), dir);
-            return scanFrond(join(frondsDir, dir), name, { path: join(frondsDir, dir), package: `@frond/${name}` }, workspaceRoot);
+            return scanFrond(join(frondsDir, dir), name, { path: join(frondsDir, dir), package: frondPackage(name, conventions) }, conventions, workspaceRoot);
         })),
     ]);
     // The app's own domain first, then the ones it took in.
     const all = rootFrond ? [rootFrond, ...under] : under;
-    const fronds = filter ? all.filter((f) => filter.includes(f.name)) : all;
-    flushCache();
+    const fronds = Fronds.scanned(filter ? all.filter((f) => filter.includes(f.name)) : all);
     return { fronds, diagnostics };
 }
 //# sourceMappingURL=scanner.js.map