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

package/src/scan/handler-parser.ts

@@ -4,6 +4,7 @@
  * The AST says what the author declared; TypeScript's checker says what those types mean.
  * TypeScript is lazy-loaded to avoid bundling the compiler in production builds.
  */
+import type { TypeRef, Param, Signature } from '../wire/signature.js';
 import type ts from '@typescript/typescript6';
 import { readFileSync, existsSync, statSync } from 'node:fs';
 import { join, dirname, resolve as resolvePath } from 'node:path';
@@ -195,7 +196,7 @@ function sourceOf(filePath: string): ts.SourceFile {
 }
 
 /** One declared parameter — a constructor's and a method's are read the same way. */
-function parsedParam(param: ts.ParameterDeclaration, source: ts.SourceFile, checker?: ts.TypeChecker): ParsedParam {
+function parsedParam(param: ts.ParameterDeclaration, source: ts.SourceFile, checker?: ts.TypeChecker): Param {
   const ts = getTS();
   const type = param.type ? parseTypeNode(param.type, source, checker) : { raw: 'unknown', name: 'unknown' };
   return {
@@ -207,63 +208,9 @@ function parsedParam(param: ts.ParameterDeclaration, source: ts.SourceFile, chec
   };
 }
 
-/** A parsed type reference — supports primitives, entities, arrays, generics. */
-export interface ParsedType {
-  /** Raw type text as written in source (e.g. 'Pagination<Post>'). */
-  raw: string;
-  /** Base type name (e.g. 'Pagination', 'string', 'Post'). */
-  name: string;
-  /** Whether this is an array (T[] or Array<T>) — true at any depth. */
-  array?: boolean;
-  /**
-   * How MANY array levels: `string[]` is 1, `string[][]` is 2. `array` only ever said
-   * "at least one", which sufficed while one level meant one thing. It stopped sufficing
-   * when a presenter method started taking the page — there the outer level IS the page
-   * and what remains is the field, so telling `string[]` from `string[][]` is telling a
-   * computed string from a computed list.
-   */
-  arrayDepth?: number;
-  /** Generic type arguments (e.g. for Pagination<Post> → [{ name: 'Post' }]). */
-  generics?: ParsedType[];
-  /** Whether `null` belongs to the type. */
-  nullable?: boolean;
-  /** Whether absence (`undefined` or `void`) belongs to the type. */
-  undefined?: boolean;
-  /** Whether this is a Promise wrapper (unwrapped in output). */
-  promise?: boolean;
-}
-
-/** A parsed method parameter. */
-export interface ParsedParam {
-  name: string;
-  type: ParsedType;
-  optional?: boolean;
-}
-
-/** A parsed method signature from a handler source file. */
-export interface ParsedMethod {
-  name: string;
-  params: ParsedParam[];
-  returnType?: ParsedType;
-  /**
-   * Came from a base class, not from the file being scanned. What a prefab
-   * handler declares about its own ops beats this — the scan reads a signature
-   * and guesses, the builder knows.
-   */
-  inherited?: boolean;
-  /**
-   * The operation in words — the first sentence of the method's doc comment.
-   *
-   * Not a new thing to write: handlers already carry it (`/** Judge: the author,
-   * a draft… *&#47;`), the AST already holds it, and nothing read it. A caller that
-   * discovers an operation over the wire has its name and its schema; what the
-   * operation is FOR lived only in the source.
-   */
-  description?: string;
-}
 
-/** Parse a TypeScript type node into a ParsedType. */
-function parseTypeNode(node: ts.TypeNode, source: ts.SourceFile, checker?: ts.TypeChecker): ParsedType {
+/** Parse a TypeScript type node into a TypeRef. */
+function parseTypeNode(node: ts.TypeNode, source: ts.SourceFile, checker?: ts.TypeChecker): TypeRef {
   const ts = getTS();
   const raw = node.getText(source);
 
@@ -373,7 +320,7 @@ function meaningfulSymbolName(type: ts.Type, checker: ts.TypeChecker): string {
 }
 
 /** Turn a checked TypeScript type into the small, serializable vocabulary the runtime reads. */
-function parseCheckedType(type: ts.Type, raw: string, checker: ts.TypeChecker, depth = 0): ParsedType {
+function parseCheckedType(type: ts.Type, raw: string, checker: ts.TypeChecker, depth = 0): TypeRef {
   const typescript = getTS();
   if (depth > 12) return { raw, name: checker.typeToString(type) };
 
@@ -545,9 +492,9 @@ function extractClassMethods(
   source: ts.SourceFile,
   skip: Set<string>,
   checker?: ts.TypeChecker,
-): ParsedMethod[] {
+): Signature[] {
   const ts = getTS();
-  const results: ParsedMethod[] = [];
+  const results: Signature[] = [];
 
   for (const member of cls.members) {
     if (!ts.isMethodDeclaration(member)) continue;
@@ -628,9 +575,9 @@ function inheritedFromBase(
   base: ts.ExpressionWithTypeArguments,
   checker: ts.TypeChecker,
   skip: Set<string>,
-): ParsedMethod[] {
+): Signature[] {
   const typescript = getTS();
-  const results: ParsedMethod[] = [];
+  const results: Signature[] = [];
 
   for (const property of checker.getPropertiesOfType(checker.getTypeAtLocation(base))) {
     if (skip.has(property.name)) continue;
@@ -676,7 +623,7 @@ function parseInheritedMethods(
    * published base class was absent from the façade without a word.
    */
   unresolved: string[],
-): ParsedMethod[] {
+): Signature[] {
   const ts = getTS();
   if (!cls.heritageClauses) return [];
 
@@ -747,7 +694,7 @@ function findDefaultClass(source: ts.SourceFile): ts.ClassDeclaration | undefine
  * pair travels through the scan cache, which is why {@link PARSER_VERSION} moved.
  */
 export interface HandlerParse {
-  methods: ParsedMethod[];
+  methods: Signature[];
   /** Base classes whose source this pass could not open. Empty is a claim. */
   unresolvedHeritage: string[];
 }
@@ -766,7 +713,7 @@ export async function parseAllHandlerMethods(filePath: string, projectRoot?: str
  *
  * Returns all methods (no CRUD filtering) — each method is a computed field.
  */
-export async function parsePresenterMethods(filePath: string, projectRoot?: string): Promise<ParsedMethod[]> {
+export async function parsePresenterMethods(filePath: string, projectRoot?: string): Promise<Signature[]> {
   await loadTS();
   // No `projectRoot`, so no heritage pass and nothing to report: a presenter's
   // computed fields are its own methods.
@@ -775,9 +722,9 @@ export async function parsePresenterMethods(filePath: string, projectRoot?: stri
 
 /**
  * Parse constructor parameter types from a source file's default class.
- * Returns type names (e.g. ['PostOrm', 'Logger']) for DI resolution.
+ * Returns type names (e.g. ['PostStorage', 'Logger']) for DI resolution.
  */
-export async function parseConstructorParams(filePath: string, projectRoot?: string): Promise<ParsedParam[]> {
+export async function parseConstructorParams(filePath: string, projectRoot?: string): Promise<Param[]> {
   const ts = await loadTS();
   const { source, checker } = checkedSourceOf(filePath, projectRoot);
   const cls = findDefaultClass(source);

package/src/scan/result.ts

@@ -0,0 +1,42 @@
+import type { Fronds } from '../descriptor/Fronds.js';
+
+/** 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[];
+}

package/src/scan/scanner.ts

@@ -1,27 +1,28 @@
 import { readdir, readFile } from 'node:fs/promises';
 import { existsSync, type Dirent } from 'node:fs';
 import { join, dirname, basename, resolve as resolvePath } from 'node:path';
-import type { FrondDescriptor, ProviderEntry, EntityEntry, HandlerEntry, PresenterEntry, CollectorEntry, SeedEntry, ScanResult, ScanDiagnostic } from './frond.js';
+import type { FrondDescriptor, ProviderEntry, EntityEntry, HandlerEntry, PresenterEntry, CollectorEntry, SeedEntry } from '../descriptor/frond.js';
+import type { ScanResult, ScanDiagnostic } from './result.js';
 import { ANONYMOUS_SCHEMA_NAME, type SchemaView } from '@fougere/schema';
 import type { OperationContract, OperationsMap } from '../wire/operation.js';
 import { cardinalityOf } from '../wire/operation.js';
-import { computeBindingPlan } from '../boot/binding.js';
+import { computeBindingPlan } from '../wire/binding.js';
 import {
   parseAllHandlerMethods,
   parsePresenterMethods,
   parseConstructorParams,
   resetTypePrograms,
   seedTypeProgram,
-  type ParsedType,
 } from './handler-parser.js';
+import type { TypeRef } from '../wire/signature.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 { storageKeyOf, togetherKeyOf } from '../storage.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 { Fronds } from '../descriptor/Fronds.js';
 import { getModuleLoader } from '../loader.js';
 import {
   type Conventions, type ConventionsInput,
@@ -132,17 +133,17 @@ function toAddress(className: string): string {
  * The container key a constructor parameter asks for — derived from its TYPE, not from
  * how the type was spelled.
  *
- * `deps` used to be `p.type.name`, so the key WAS the alias's name: `type ListOrm =
- * EntityOrm<List>` resolved only because someone had spelled it exactly like the
- * registration key (`ListOrm`), while `type ListRepo = EntityOrm<List>` — the same type —
- * typechecked and died at boot on `'ListRepo' is not registered`. And `EntityOrm<List>`
- * written out in full asked for `'EntityOrm'`, which nothing registers.
+ * `deps` used to be `p.type.name`, so the key WAS the alias's name: `type ListStorage =
+ * Storage<List>` resolved only because someone had spelled it exactly like the
+ * registration key (`ListStorage`), while `type ListRepo = Storage<List>` — the same type —
+ * typechecked and died at boot on `'ListRepo' is not registered`. And `Storage<List>`
+ * written out in full asked for `'Storage'`, which nothing registers.
  *
- * `EntityOrm<X>` names X's storage, so that is the key. The generic argument was already
- * parsed (`ParsedType.generics`) and thrown away. Anything else keeps its own name: a
+ * `Storage<X>` names X's storage, so that is the key. The generic argument was already
+ * parsed (`TypeRef.generics`) and thrown away. Anything else keeps its own name: a
  * plain service IS designated by its class name.
  */
-function depKeyOf(type: ParsedType): string {
+function depKeyOf(type: TypeRef): string {
   // `Facade<PostHandler>` — the second port, read exactly like the first. The type names
   // what arrives: not the handler (its methods take positional arguments and it is never
   // injected), but the door built in front of it. Same key whether that door is the local
@@ -168,10 +169,10 @@ function depKeyOf(type: ParsedType): string {
   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;
+  const target = type.name === 'Storage' ? type.generics?.[0]?.name : undefined;
   if (!target) return type.name;
 
-  return ormKeyOf(target);
+  return storageKeyOf(target);
 }
 
 /**
@@ -179,7 +180,7 @@ function depKeyOf(type: ParsedType): string {
  *
  * 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
+ * while the tuple maps to `[Storage<Account>, Storage<Ledger>]` in one line. The
  * parser does not get to decide alone; this split is what that choice costs.
  */
 function tupleMembers(raw: string): string[] {
@@ -216,9 +217,9 @@ async function toProvider(filePath: string): Promise<ProviderEntry> {
   const owned = ownedBy(ctor);
   const target = targetOf(ctor);
   if (owned.length > 1 && deps.length === 0) {
-    deps.push(...owned.map((entity) => ormKeyOf(lowerFirst((entity as { name: string }).name))));
+    deps.push(...owned.map((entity) => storageKeyOf(lowerFirst((entity as { name: string }).name))));
   } else if (target && deps.length === 0) {
-    deps.push(ormKeyOf(lowerFirst((target as { name: string }).name)));
+    deps.push(storageKeyOf(lowerFirst((target as { name: string }).name)));
   }
 
   // No `name` beside `ctor`: a provider registers under `ctor.name`, which is what
@@ -243,10 +244,10 @@ async function toEntityEntry(filePath: string): Promise<EntityEntry | null> {
 }
 
 /**
- * Resolve a ParsedType to a runtime schema if available in module exports.
+ * Resolve a TypeRef to a runtime schema if available in module exports.
  * Handles arrays, generics (uses base name), and simple references.
  */
-function resolveSchema(type: ParsedType, moduleExports: Record<string, unknown>): SchemaView | undefined {
+function resolveSchema(type: TypeRef, moduleExports: Record<string, unknown>): SchemaView | undefined {
   // 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
@@ -751,7 +752,29 @@ export async function scanProject(
 
   // The app's own domain first, then the ones it took in.
   const all = rootFrond ? [rootFrond, ...under] : under;
-  const fronds = Fronds.scanned(filter ? all.filter((f) => filter.includes(f.name)) : all);
+  const fronds = Fronds.hosting(filter ? all.filter((f) => filter.includes(f.name)) : all);
 
   return { fronds, diagnostics };
 }
+
+/**
+ * What changes when a frond's domain changes — the paths a dev loop watches.
+ *
+ * It lives beside the scan rather than beside the conventions it reads, because it turns
+ * names into DISK paths: `join` is `node:path`, and `conventions.ts` is reached from
+ * `index` through `frond()`, which an edge bundle imports. Measured — esbuild refused the
+ * Worker with `Could not resolve "node:path"`.
+ *
+ * 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/statement.ts

@@ -18,7 +18,8 @@
  * — same rows, same computed fields, and no `typescript` loaded at boot.
  */
 import { relative } from 'node:path';
-import type { FrondDescriptor, ScanResult } from './frond.js';
+import type { FrondDescriptor } from '../descriptor/frond.js';
+import type { ScanResult } from './result.js';
 
 type Live = { name?: string };
 

package/src/{orm.ts → storage.ts}

@@ -1,4 +1,4 @@
-import { upperFirst, type SchemaView } from '@fougere/schema';
+import { upperFirst, lowerFirst, type SchemaView } from '@fougere/schema';
 
 /** Options for list queries — pagination, sorting, counting. */
 export interface ListOptions {
@@ -68,8 +68,8 @@ export interface SelectOption {
   select?: SchemaView;
 }
 
-/** Per-entity ORM — scoped CRUD operations on a single entity type. */
-export interface EntityOrm<T = Record<string, unknown>> {
+/** Per-entity storage — scoped CRUD operations on a single entity type. */
+export interface Storage<T = Record<string, unknown>> {
   list(options?: ListOptions & SelectOption): Promise<ListResult<T>>;
   findById(id: string, options?: SelectOption): Promise<T | undefined>;
   /**
@@ -78,7 +78,7 @@ export interface EntityOrm<T = Record<string, unknown>> {
    *
    * 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
+   * in (`storage as StorageWithFindBy`), 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.
    */
@@ -137,15 +137,15 @@ export interface EntityOrm<T = Record<string, unknown>> {
   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>;
+  /** Returns a scoped storage that restricts all read results to the fields of the given schema. */
+  output(schema: SchemaView): Storage<T>;
   /**
-   * What this ORM wraps — the Kysely instance for the SQL one, something else elsewhere.
+   * What this storage 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
+   * Every judge sits on the storage'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.
+   * gave you — `productStorage.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.
@@ -154,13 +154,106 @@ export interface EntityOrm<T = Record<string, unknown>> {
 }
 
 /**
- * Factory that creates an EntityOrm for a given entity.
+ * Factory that creates a Storage for a given entity.
  * Called by bootstrap for every scanned entity.
  */
-export type OrmFactory = (entity: SchemaView, name: string) => EntityOrm;
+export type StorageFactory = (entity: SchemaView, name: string) => Storage;
 
 /**
- * Container key of an entity's storage — 'reading' → 'ReadingOrm'.
+ * A place rows live, whatever realizes it.
+ *
+ * `StorageFactory` plus its lifecycle, which is why it lives beside it. Three of the four
+ * gestures are optional and ABSENCE IS THE ANSWER: no `transacted` and a frame compensates
+ * instead of transacting (`boot/together.ts`), no `migrate` and there is no shape to bring
+ * up to date. What a source is MADE OF is not here — `adapter/sql` states `dialect`, `db`
+ * and `sink` on its own `SqlSource`, reached by narrowing, the rule {@link Storage.client}
+ * already obeys one level down.
+ */
+export interface Source {
+  storageFactory: StorageFactory;
+  /** Bring the shape of what lives here up to date. */
+  migrate?(view: SourceView): Promise<void>;
+  /** Run `fn` as ONE unit of work, with a factory bound to it. */
+  transacted?<R>(fn: (factory: StorageFactory) => Promise<R>): Promise<R>;
+  close?(): Promise<void>;
+  /** What distinguishes it when a query is reported. */
+  name?: string;
+}
+
+/**
+ * The app as ONE source sees it: what lives there, and the NAMES of what does not.
+ *
+ * The second half is what lets a DDL stop lying. A batch holding every entity cannot tell
+ * a cross-source target from a typo, so a `ref()` falls back to a derived table name and
+ * the constraint is emitted against a table that may not exist. `elsewhere` says which
+ * misses are legitimate — and a target in neither list is a mistake, out loud.
+ */
+export interface SourceView {
+  fronds: readonly { readonly name: string; readonly entities: readonly { readonly name: string }[] }[];
+  /** The auth provider's own entities, when they ride with this source. */
+  auth?: unknown;
+  elsewhere: readonly string[];
+}
+
+/**
+ * What a config file can carry about a source — values, never a live driver.
+ *
+ * `source` names the ADAPTER, and everything else belongs to the adapter it named:
+ * `adapter/sql` reads `dialect`, a file one reads `path`. That is the shape
+ * `EntityAdapters` already has — addressed by adapter, and what sits below is the
+ * adapter's own. Which is why the level `schema` owns is not repeated here.
+ */
+export interface SourceConfig {
+  /** The adapter that realizes it. Absent means the conventional one. */
+  source?: string;
+  /** The entities whose rows live here. Absent on the default source: it holds the rest. */
+  entities?: string[];
+  [key: string]: unknown;
+}
+
+/**
+ * Which adapter answers a source name — one per process, no subject to hold.
+ *
+ * The shape `Generators` already has, and the refusal `resolveStorage` already made: only
+ * `sqlite` could be resolved from its name, because it was the one driver `defaults`
+ * depended on. That refusal had no owner — it lived in the package that happened to import
+ * the driver — so a second adapter had nowhere to say it exists. Here it does, and an
+ * unknown name is refused naming what this process answers.
+ *
+ * Registered at IMPORT by each adapter, so nothing central lists them.
+ */
+export class Sources {
+  private static readonly registry = new Map<string, (conf: SourceConfig) => Source>();
+
+  static register(name: string, build: (conf: SourceConfig) => Source): void {
+    this.registry.set(name, build);
+  }
+
+  /** The source this name stands for, refused by name when nothing does. */
+  static resolve(name: string, conf: SourceConfig): Source {
+    const build = this.registry.get(name);
+    if (build) return build(conf);
+
+    throw new Error(
+      `Unknown source '${name}' — import the adapter that answers it, or register one with `
+      + `Sources.register('${name}', build). This process answers `
+      + `${[...this.registry.keys()].join(', ') || 'nothing yet'}.`,
+    );
+  }
+
+  /** Whether a name is answered, for a caller that must not throw to find out. */
+  static answers(name: string): boolean {
+    return this.registry.has(name);
+  }
+
+  /** What this process answers — what a refusal elsewhere prints. */
+  static answered(): string[] {
+    return [...this.registry.keys()];
+  }
+}
+
+/**
+ * Container key of an entity's storage — 'reading' → 'ReadingStorage'.
  *
  * 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
@@ -168,14 +261,30 @@ export type OrmFactory = (entity: SchemaView, name: string) => EntityOrm;
  * 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`;
+export function storageKeyOf(entity: string): string {
+  return `${upperFirst(entity)}${HELD}`;
+}
+
+/**
+ * The entity behind a storage key, or `undefined` when the key is not one.
+ *
+ * The dual of the line above, for the reason `membersOfTogetherKey` is. `known` is what the
+ * suffix alone cannot answer: `FileStorage` is an ordinary class name.
+ */
+export function entityOfStorageKey(key: string, known: (entity: string) => boolean): string | undefined {
+  if (key.length <= HELD.length || !key.endsWith(HELD)) return undefined;
+  const entity = lowerFirst(key.slice(0, -HELD.length));
+
+  return storageKeyOf(entity) === key && known(entity) ? entity : undefined;
 }
 
+/** What a holder keeps, said in the key it is registered under. */
+const HELD = 'Storage';
+
 /**
  * `Together<[Account, Ledger]>` — writes that stand or fall as one.
  *
- * `EntityOrm` is the port whose every gesture is ONE statement, and one statement is
+ * `Storage` 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
@@ -191,7 +300,7 @@ export function ormKeyOf(entity: string): string {
  * ```
  *
  * **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
+ * covered too — a `Mirror` writes its pages through `Storage<T>`, so naming it puts
  * them under the same unwind, with no locator and no second injection path:
  *
  * ```ts
@@ -214,7 +323,7 @@ export function ormKeyOf(entity: string): string {
  * 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>;
+  run<R>(fn: (entities: { [K in keyof E]: Storage<E[K]> }, providers: P) => Promise<R>): Promise<R>;
 }
 
 /**

package/src/verify.ts

@@ -1,7 +1,7 @@
-import type { FrondDescriptor } from './scan/frond.js';
+import type { FrondDescriptor } from './descriptor/frond.js';
 import { lowerFirst } from '@fougere/schema';
 import { repositoryKeyOf } from './prefab/repository.js';
-import { ormKeyOf } from './orm.js';
+import { storageKeyOf } from './storage.js';
 import { presenterKeyOf } from './prefab/presenter.js';
 import { collectorKeyOf } from './prefab/collector.js';
 
@@ -63,7 +63,7 @@ function registrationsOf(frond: FrondDescriptor): Map<string, Registration> {
   for (const p of frond.presenters) put(presenterKeyOf(p.entityName), 'presenter');
   for (const c of frond.collectors) put(collectorKeyOf(c.typeName), 'collector');
   for (const e of frond.entities) {
-    put(ormKeyOf(e.name), 'ORM');
+    put(storageKeyOf(e.name), 'storage');
     put(repositoryKeyOf(e.name), 'repository');
   }
   return out;

package/src/{boot → wire}/binding.ts

@@ -6,8 +6,7 @@
  * be repeated here too, and it had already lost `Fact` — the one whose position is
  * load-bearing, since the fall-through would otherwise hand it the caller's body.
  */
-import type { ParsedParam } from '../scan/handler-parser.js';
-import type { InvocationContext } from '../contract/Invocation.js';
+import type { Param } from './signature.js';
 import { lowerFirst } from '@fougere/schema';
 
 // ── Types ─────────────────────────────────────
@@ -56,7 +55,7 @@ function coercionFor(typeName: string): 'number' | 'boolean' | undefined {
  * @param collectorTypeNames - Registration keys of the types a Collector answers for
  */
 export function computeBindingPlan(
-  params: ParsedParam[],
+  params: Param[],
   collectorTypeNames: Set<string>,
 ): BindingPlan {
   return params.map((param) => {
@@ -117,66 +116,3 @@ export function computeBindingPlan(
     };
   });
 }
-
-// ── Resolve ───────────────────────────────────
-
-export interface CollectorResolver {
-  collect(ctx: InvocationContext): Promise<unknown>;
-}
-
-/**
- * Resolve handler arguments from a BindingPlan + InvocationContext.
- */
-export async function resolveArgs(
-  plan: BindingPlan,
-  ctx: InvocationContext,
-  resolveCollector?: (typeName: string) => CollectorResolver | undefined,
-): Promise<unknown[]> {
-  const args: unknown[] = [];
-
-  for (const binding of plan) {
-    switch (binding.source.kind) {
-      case 'collector': {
-        const collector = resolveCollector?.(binding.source.typeName);
-        args.push(collector ? await collector.collect(ctx) : undefined);
-        break;
-      }
-      case 'context': {
-        args.push(ctx);
-        break;
-      }
-      case 'param': {
-        // `null` is a value, not a miss. Nullish coalescing used to make an explicit
-        // nullable path/GraphQL argument fall through to query (or become undefined),
-        // collapsing `T | null` into `T | undefined`. Only undefined means absent.
-        const fromParams = ctx.params[binding.source.name];
-        let val: unknown = fromParams === undefined
-          ? ctx.query[binding.source.name]
-          : fromParams;
-        if (val != null && binding.source.coerce === 'number') val = Number(val);
-        if (val != null && binding.source.coerce === 'boolean') val = val === 'true' || val === '1' || val === true;
-        args.push(val);
-        break;
-      }
-      case 'fact': {
-        // A fact IS the payload — the whole of what happened, never a piece of it.
-        // Identical to `body` today, and deliberately not sharing its branch: the two
-        // agree by coincidence, not by rule, and the day `body` learns to look up a
-        // value by parameter name a subscriber would receive ONE FIELD of the fact it
-        // subscribed to. Splitting it costs nothing and removes that trap.
-        args.push(ctx.body);
-        break;
-      }
-      case 'body': {
-        args.push(ctx.body);
-        break;
-      }
-      case 'query': {
-        args.push(ctx.query);
-        break;
-      }
-    }
-  }
-
-  return args;
-}