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

package/src/imports.ts

@@ -25,7 +25,7 @@
 import type ts from '@typescript/typescript6';
 import { readdir, readFile } from 'node:fs/promises';
 import { join, resolve, dirname, relative, isAbsolute } from 'node:path';
-import type { FrondDescriptor } from './scan/frond.js';
+import type { FrondDescriptor } from './descriptor/frond.js';
 
 let _ts: typeof ts | undefined;
 async function loadTs(): Promise<typeof ts> {

package/src/index.ts

@@ -40,17 +40,17 @@ export type { DispatchObserver } from './dispatch/DispatchEvent.js';
 export type { DispatchPort } from './dispatch/DispatchPort.js';
 export {
   inferOperationKind,
-  resolveContracts,
   resolveIsReadOp,
   resolveOperationKind,
 } from './wire/operation.js';
+export { resolveContracts } from './effective-operation.js';
 export type {
   OperationContract,
   OperationKind,
   OperationKindInference,
   OperationsMap,
-  ParsedParam,
-  ParsedType,
+  Param,
+  TypeRef,
 } from './wire/operation.js';
 export {
   EFFECTIVE_OPERATION_SEMANTICS,
@@ -67,16 +67,17 @@ export type {
 export type { ModuleLoader } from './loader.js';
 export { FougereError, ErrorCode, validationErrorsOf, type FougereErrorOptions } from './wire/errors.js';
 export type { OperationContext, AppNext, AppMiddleware } from './wire/middleware.js';
-export { createLocalRunner, createAppRunner, assertIdentityCard, RPC_ENTITY, MAX_BODY_BYTES } from './wire/call.js';
+export { assertIdentityCard, RPC_ENTITY, MAX_BODY_BYTES } from './wire/call.js';
+export { createLocalRunner, createAppRunner } from './boot/runner.js';
 
 // A frond an app STATES, for a boot that will not scan. No disk, no `typescript` — which
 // is why it sits here and not in `/node`, beside the scanner that reads a project.
-export { frond } from './scan/declare.js';
-export type { FrondDeclaration, Declared, DeclaredSubject } from './scan/declare.js';
+export { frond } from './declare.js';
+export type { FrondDeclaration, Declared, DeclaredSubject } from './declare.js';
 // What this app would answer to `rpc.discover`. Served by the boot, and reached until now
 // only by tests through a deep path — a consumer comparing its own card to a producer's
 // had to dispatch a call to ask a question about itself.
-export { identityCardOf } from './wire/call.js';
+export { identityCardOf } from './boot/card.js';
 export type {
   FrondCall, Transport, IdentityCard, CardOp, Facade, RpcAnswer,
   TopologyReport, FrondPlacement, Edge,
@@ -91,12 +92,13 @@ export type { LogLevel, LogRecord, LogSink } from './builtins/logger.js';
 // What a re-read config changes in a running process — and what it cannot.
 export { applyConfig, type ConfigApplication } from './boot/apply.js';
 export { Config } from './builtins/config.js';
-export type { EntityOrm, OrmFactory, ListOptions, ListResult, Together } from './orm.js';
-export { togetherKeyOf, membersOfTogetherKey } from './orm.js';
+export type { Storage, StorageFactory, Source, SourceConfig, SourceView, ListOptions, ListResult, Together } from './storage.js';
+export { Sources, togetherKeyOf, membersOfTogetherKey } from './storage.js';
+export { storageOver } from './rows.js';
+export type { Rows, Row } from './rows.js';
 export type { App, CreateAppOptions } from './boot/types.js';
+export type { ScanResult, ScanDiagnostic } from './scan/result.js';
 export type {
-  ScanResult,
-  ScanDiagnostic,
   FrondDescriptor,
   FrondSource,
   ProviderEntry,
@@ -107,9 +109,9 @@ export type {
   PresenterEntry,
   PresenterFieldMeta,
   CollectorEntry,
-} from './scan/frond.js';
+} from './descriptor/frond.js';
 export type { AuthConfig, AuthContext, AuthRuntime } from './boot/auth.js';
-export { Fronds } from './scan/Fronds.js';
+export { Fronds } from './descriptor/Fronds.js';
 export { verify, assertSplittable, type Violation } from './verify.js';
 // Same question as verify(), answered from the source text instead of the model.
 export type { CrossFrondImport } from './imports.js';

package/src/node.ts

@@ -11,10 +11,10 @@
  */
 export { boot } from './boot/boot.js';
 
-export { scanProject, frondAliases } from './scan/scanner.js';
+export { scanProject, frondAliases, watchPathsOf } from './scan/scanner.js';
 export {
   type Conventions, type ConventionsInput, DEFAULT_CONVENTIONS,
-  resolveConventions, frondPackage, frondDirsOf, providerDirsOf, watchPathsOf,
+  resolveConventions, frondPackage, frondDirsOf, providerDirsOf,
 } from './scan/conventions.js';
 export { RUNTIME_PACKAGES } from './scan/bundling.js';
 export { emitScan, type EmitOptions } from './scan/emit.js';

package/src/prefab/collector.ts

@@ -12,10 +12,10 @@
  * Usage:
  * ```ts
  * export default class UserCollector extends Collector(User) {
- *   constructor(private userOrm: UserOrm) { super(); }
+ *   constructor(private userStorage: UserStorage) { super(); }
  *
  *   async collect(ctx: InvocationContext) {
- *     return this.userOrm.findById(ctx.state.userId as string);
+ *     return this.userStorage.findById(ctx.state.userId as string);
  *   }
  * }
  * ```

package/src/prefab/crud.ts

@@ -1,4 +1,4 @@
-import type { EntityOrm, ListOptions, ListResult } from '../orm.js';
+import type { Storage, ListOptions, ListResult } from '../storage.js';
 import type { OperationContract } from '../wire/operation.js';
 import type { EntityConstructor, SchemaView } from '@fougere/schema';
 
@@ -79,7 +79,7 @@ function crudOps(entity: SchemaView & { partial?: () => SchemaView }): Record<st
 /**
  * The mixin's single "trust me" point — the twin of `asSchemaConstructor` in @fougere/schema.
  *
- * The implementation returns whatever the ORM hands back; the declaration names the view
+ * The implementation returns whatever the storage hands back; the declaration names the view
  * each op emits at the port. TypeScript cannot connect the two (the view is a runtime
  * argument, the type is a generic), so one assertion states that the mixin honours what it
  * declared — and the façade makes it true, projecting each op's result onto its view
@@ -121,7 +121,7 @@ type OutOf<V, K extends CrudOpName, T> =
  * a judged redefinition assignable.
  */
 export interface CrudOps<T, V = {}> {
-  orm: EntityOrm<T>;
+  storage: Storage<T>;
   list(options?: ListOptions, ...collected: never[]): Promise<ListResult<OutOf<V, 'list', T>>>;
   findById(id: string, ...collected: never[]): Promise<OutOf<V, 'findById', T> | undefined>;
   create(input: Partial<T>, ...collected: never[]): Promise<OutOf<V, 'create', T>>;
@@ -131,10 +131,10 @@ export interface CrudOps<T, V = {}> {
 
 /** The prefab handler class — its ops, plus the statics the bootstrap and adapters read. */
 export interface CrudConstructor<T, V = {}> {
-  // `EntityOrm<T>`, not the bare `EntityOrm`: a handler that injects a second ORM has to
-  // spell its own constructor, and `super(orm)` with the ORM the container hands it —
-  // typed on the entity, as the `orm` property below already says — was refused.
-  new (orm: EntityOrm<T>): CrudOps<T, V>;
+  // `Storage<T>`, not the bare `Storage`: a handler that injects a second storage has to
+  // spell its own constructor, and `super(storage)` with the storage the container hands it —
+  // typed on the entity, as the `storage` property below already says — was refused.
+  new (storage: Storage<T>): CrudOps<T, V>;
   readonly __entity: unknown;
   readonly __output: unknown;
   readonly __opOutputs?: CrudViews;
@@ -149,10 +149,10 @@ export interface CrudConstructor<T, V = {}> {
  *
  * Crud(Post)                      → every op emits Post
  * Crud(Post, { list: PostCard })  → list emits cards, the rest emit Post. Declaration
- *                                   only: the handler keeps its full-row ORM, so a
+ *                                   only: the handler keeps its full-row storage, so a
  *                                   judge can still read `body`.
  * Crud(Post, PostPublic)          → every op emits PostPublic, and the bootstrap
- *                                   scopes the injected ORM via .output(PostPublic) —
+ *                                   scopes the injected storage via .output(PostPublic) —
  *                                   the whole handler speaks the restricted view.
  */
 export function Crud<E extends EntityConstructor, V extends CrudViews | EntityConstructor = {}>(
@@ -168,21 +168,21 @@ export function Crud<E extends EntityConstructor, V extends CrudViews | EntityCo
 
   return asCrudConstructor<T, V>(class CrudHandler {
     static __entity = entity;
-    /** Handler-wide view only — a per-op map must NOT scope the ORM the judges read. */
+    /** Handler-wide view only — a per-op map must NOT scope the storage the judges read. */
     static __output = wholeHandler ?? entity;
     static __opOutputs = perOp;
     /** What this prefab handler declares — read by the façade, merged under the author's own methods. */
     static __ops: Record<string, OperationContract> = crudOps(entity as unknown as SchemaView & { partial?: () => SchemaView });
 
-    orm: EntityOrm<T>;
-    constructor(orm: EntityOrm) {
-      this.orm = orm as EntityOrm<T>;
+    storage: Storage<T>;
+    constructor(storage: Storage) {
+      this.storage = storage as Storage<T>;
     }
 
-    async list(options?: ListOptions): Promise<ListResult<T>> { return this.orm.list(options) as Promise<ListResult<T>>; }
-    async findById(id: string): Promise<T | undefined> { return this.orm.findById(id); }
-    async create(input: Partial<T>): Promise<T> { return this.orm.create(input); }
-    async update(id: string, input: Partial<T>): Promise<T> { return this.orm.update(id, input); }
-    async delete(id: string): Promise<boolean> { return this.orm.delete(id); }
+    async list(options?: ListOptions): Promise<ListResult<T>> { return this.storage.list(options) as Promise<ListResult<T>>; }
+    async findById(id: string): Promise<T | undefined> { return this.storage.findById(id); }
+    async create(input: Partial<T>): Promise<T> { return this.storage.create(input); }
+    async update(id: string, input: Partial<T>): Promise<T> { return this.storage.update(id, input); }
+    async delete(id: string): Promise<boolean> { return this.storage.delete(id); }
   });
 }

package/src/prefab/mirror.ts

@@ -1,5 +1,5 @@
 import { FieldSet, Lifecycle, type EntityConstructor, type Fields, type ValidationResult } from '@fougere/schema';
-import type { EntityOrm } from '../orm.js';
+import type { Storage } from '../storage.js';
 
 /**
  * A paginated local copy of a source that cannot be queried directly.
@@ -9,8 +9,8 @@ import type { EntityOrm } from '../orm.js';
  *
  * ```ts
  * export default class PartnerCatalog extends Mirror(BookCard) {
- *   constructor(orm: EntityOrm<BookCard>, private catalog: Facade<CatalogHandler>) {
- *     super(orm);
+ *   constructor(storage: Storage<BookCard>, private catalog: Facade<CatalogHandler>) {
+ *     super(storage);
  *   }
  *
  *   async *pull(since?: Date) {
@@ -36,7 +36,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 +46,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 +66,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 +84,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(judgePage(shape, page) as Partial<T>[]);
       }
       return { written, since, ms: Date.now() - started };
     }

package/src/prefab/presenter.ts

@@ -9,14 +9,14 @@
  * Usage:
  * ```ts
  * export default class PostPresenter extends Presenter(Post) {
- *   constructor(private commentOrm: CommentOrm) { super(); }
+ *   constructor(private commentStorage: CommentStorage) { super(); }
  *
  *   excerpt(post: Post) {
  *     return post.body.slice(0, 200);
  *   }
  *
  *   async commentCount(post: Post) {
- *     return this.commentOrm.countFor(post.id);
+ *     return this.commentStorage.countFor(post.id);
  *   }
  * }
  * ```

package/src/prefab/repository.ts

@@ -1,12 +1,12 @@
 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.
+ * **The arity decides**, which is the second reading of what `storage.ts` already states for
+ * `Storage` 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
@@ -30,13 +30,13 @@ import type { SchemaView } from '@fougere/schema';
  * // repositories/CommandeRepository.ts
  * export default class CommandeRepository extends Repository(Commande, Stock) {
  *   avecLignes(id: string) {
- *     const [commandes, stock] = this.orms;
+ *     const [commandes, stock] = this.storages;
  *     …
  *   }
  * }
  * ```
  *
- * `this.orms` is protected, because the whole point is that the storage stops at this file.
+ * `this.storages` 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.
  *
@@ -48,12 +48,12 @@ import type { SchemaView } from '@fougere/schema';
  * 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]>) {
+ * constructor(commandes: CommandeStorage, stock: StockStorage, 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 storage 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.
@@ -62,14 +62,14 @@ import type { SchemaView } from '@fougere/schema';
 /**
  * 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
+ * to `PostRepository` what `Storage<Post>` is to `PostStorage`, one spelling of one key, and
  * `depKeyOf` reads both.
  */
-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;
 }
 
@@ -81,15 +81,15 @@ export interface RepositoryConstructor<T> {
  * 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]>> };
+  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;
@@ -111,24 +111,24 @@ export function Repository(...entities: EntityConstructor[]): unknown {
 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>;
@@ -144,10 +144,10 @@ function many<E extends readonly EntityConstructor[]>(entities: E): AggregateCon
     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>;
     }
   }
 

package/src/rows.ts

@@ -0,0 +1,155 @@
+/**
+ * The thirteen gestures of {@link Storage}, derived from four.
+ *
+ * A place rows live varies in ONE thing — how a row is fetched, written, dropped and
+ * enumerated. Everything above that is the same everywhere: what a page is, how a criterion
+ * matches, which stamps survive an upsert, and the two refusals a `create` owes its caller.
+ * Measured on the Map realization: 14 lines of 140 touched the store.
+ *
+ * So an adapter supplies {@link Rows} and receives a whole `StorageFactory`. It is the frame
+ * a third party writing a source needs — without it, `Sources.register` hands over a
+ * four-gesture contract and leaves the thirteen to be re-derived, which is how three
+ * divergent copies of the same store ended up in this repo's own demos.
+ *
+ * What is NOT here: `transacted`. A unit of work belongs to the engine that has one, and
+ * this frame has none — which is why a `Source` built on it leaves the key absent and a
+ * frame compensates.
+ */
+import { applyCreate, applyUpdate, Lifecycle, Role, type SchemaView } from '@fougere/schema';
+import type { Storage, StorageFactory } from './storage.js';
+
+/** One row, as every realization hands it over. */
+export type Row = Record<string, unknown>;
+
+/**
+ * A keyed collection of rows — what an adapter supplies, and all of it.
+ *
+ * Async on purpose, even where a realization is not: a Map answers instantly and a directory
+ * does not, and the frame above cannot be written twice. `client` is what the port's own
+ * escape hatch exposes, `unknown` for the reason it is there.
+ */
+export interface Rows {
+  get(key: string): Promise<Row | undefined>;
+  has(key: string): Promise<boolean>;
+  set(key: string, row: Row): Promise<void>;
+  delete(key: string): Promise<boolean>;
+  /** Every row it holds. A realization that cannot answer this cheaply says so in its doc. */
+  all(): Promise<Row[]>;
+  /** Handed on as `Storage.client` — the Map, the directory, whatever it is. */
+  readonly client: unknown;
+}
+
+export function storageOver(open: (entity: SchemaView, name: string) => Rows): StorageFactory {
+  return (entity: SchemaView, name: string): Storage => {
+    const fields = entity.getFields();
+    const rows = open(entity, name);
+    const pk = Object.entries(fields).find(([, field]) => Role.of(field).isPrimary)?.[0] ?? 'id';
+    // `Storage.findById(id: string)` — but a key can hold a number, and a Map keyed on
+    // `1` does not answer `'1'`. SQL never had the question; here the divergence was
+    // silent and only on this storage.
+    const keyOf = (value: unknown) => String(value);
+    // Same contract as SQL: a criterion may name a SET, and an empty set matches nothing.
+    const matches = (row: Record<string, unknown>, criteria: Record<string, unknown>) =>
+      Object.entries(criteria).every(([key, value]) => Array.isArray(value)
+        ? value.some((v) => Object.is(row[key], v))
+        : Object.is(row[key], value));
+    return {
+      client: rows.client,
+      async list(options?: any) {
+        let items = await rows.all();
+        if (options?.where) items = items.filter((row) => matches(row, options.where));
+        // Held before the page is cut, and after the filter: `total` answers "how many
+        // match", which is what a paginator divides. Reading `store.size` at the end
+        // answered a different question — every row the store holds, including the ones
+        // the filter exists to keep out of this caller's sight.
+        const matching = items.length;
+        const limit = options?.limit;
+        const offset = options?.page && limit ? (options.page - 1) * limit : options?.offset ?? 0;
+        if (offset > 0) items = items.slice(offset);
+        const hasMore = limit ? items.length > limit : false;
+        if (limit) items = items.slice(0, limit);
+        const result = items as any;
+        result.hasMore = hasMore;
+        result.endCursor = items.length > 0 ? String((items[items.length - 1] as any)[pk] ?? '') : undefined;
+        if (options?.count) result.total = matching;
+        return result;
+      },
+      async findById(id: string) { return await rows.get(keyOf(id)); },
+      async findBy(criteria: Record<string, unknown>) {
+        return (await rows.all()).find((row) => matches(row, criteria));
+      },
+      async findAllBy(criteria: Record<string, unknown>) {
+        return (await rows.all()).filter((row) => matches(row, criteria));
+      },
+      // Same contract as SQL: a map keyed by the primary key, a miss being an absent key.
+      async findByKeys(ids: readonly string[]) {
+        const found = new Map<string, Record<string, unknown>>();
+        for (const id of ids) {
+          const row = await rows.get(keyOf(id));
+          if (row) found.set(String(id), row);
+        }
+        return found;
+      },
+      // The dual, same contract as SQL: grouped by the value read off the ROW.
+      async findAllByKeys(field: string, keys: readonly string[]) {
+        const grouped = new Map<string, Record<string, unknown>[]>();
+        if (keys.length === 0) return grouped;
+        const wanted = new Set(keys.map(String));
+        for (const row of await rows.all()) {
+          const key = String(row[field]);
+          if (!wanted.has(key)) continue;
+          const held = grouped.get(key);
+          if (held) held.push(row); else grouped.set(key, [row]);
+        }
+        return grouped;
+      },
+      // Same contract as SQL: the key and the creation stamps survive an overwrite.
+      async upsert(input: Partial<Record<string, unknown>>) {
+        const record = applyCreate(fields, applyUpdate(fields, input));
+        const id = record[pk] as string | undefined;
+        if (id === undefined) throw new Error(`${name}.upsert(): no \`${pk}\` — an upsert needs the key it writes at.`);
+        const held = await rows.get(keyOf(id));
+        if (held) {
+          for (const [key, field] of Object.entries(fields)) {
+            if (key === pk || Lifecycle.of(field).stampedOnce) record[key] = held[key];
+          }
+        }
+        await rows.set(keyOf(id), record);
+        return record;
+      },
+      async upsertAll(inputs: readonly Partial<Record<string, unknown>>[]) {
+        for (const input of inputs) await this.upsert(input);
+        return inputs.length;
+      },
+      async create(input: Partial<Record<string, unknown>>) {
+        const record = applyCreate(fields, input);
+        const id = record[pk] as string | undefined;
+        // `primary(text())` declares no generator, so nothing fills the hole and the
+        // caller has to. Keying on `undefined` would let the second create overwrite the
+        // first, in silence — the old version hid this by inventing an `id` field the
+        // entity never declared.
+        if (id === undefined) {
+          throw new Error(`${name}.create: '${pk}' is the primary key and nothing supplied it — this entity declares no generator for it.`);
+        }
+        // A create is not an upsert. `Map.set` overwrites, so a second create under the
+        // same key answered "created" while destroying the previous row — SQL answers a
+        // constraint violation, and a store that loses data silently is worse than one
+        // that fails.
+        if (await rows.has(keyOf(id))) {
+          throw new Error(`${name}.create: '${pk}' ${JSON.stringify(id)} already exists.`);
+        }
+        await rows.set(keyOf(id), record);
+        return record;
+      },
+      async update(id: string, input: Partial<Record<string, unknown>>) {
+        const existing = await rows.get(keyOf(id));
+        if (!existing) throw new Error(`Not found: ${id}`);
+        const updated = { ...existing, ...applyUpdate(fields, input), [pk]: existing[pk] };
+        await rows.set(keyOf(id), updated);
+        return updated;
+      },
+      async delete(id: string) { return await rows.delete(keyOf(id)); },
+      output(_schema: SchemaView) { return this; },
+    };
+  };
+}

package/src/scan/conventions.ts

@@ -6,7 +6,6 @@
  * 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 {
   /**
@@ -103,20 +102,3 @@ export function frondDirsOf(conventions: Conventions): string[] {
     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/emit.ts

@@ -16,10 +16,8 @@
  */
 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 {
@@ -222,7 +220,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(', ')}],