@fougere/core 0.12.2-alpha.0 → 0.12.4-alpha.0

package/src/boot/install.ts

@@ -457,90 +457,51 @@ function buildFacadeInto(
   ));
 }
 
-export async function installFrond(frond: FrondDescriptor, assembly: Assembly): Promise<void> {
-  const {
-    container, routeRegistry, emissions, dispatcher, localDispatcher, effectiveByKey,
-    boundPorts, refused, operationModel, entityByName, frondOf, contractsOf, getMiddlewares, use,
-    log, options,
-  } = assembly;
-
-  // Declared remote: keep the scanned metadata (bridges route with it),
-  // register nothing locally — resolve() falls through to the remote façade.
-  if (options.remotes && frond.name in options.remotes) {
-    log.child(frond.name).info('declared remote — not hosted locally');
-    // Its facades answer elsewhere, but what they LISTEN to was read here.
-    for (const handler of frond.handlers) {
-      const key = facadeKeyOf(handler.address, handler.surface);
-      const operations = operationModel.forHandler(handler);
-      effectiveByKey.set(key, operations);
-      emissions.note(contractsOf(operations), key);
-
-    }
-
-    return;
+/** Its facades answer elsewhere, but what they LISTEN to is read here, and the bridges route with it. */
+function noteRemoteFrond(frond: FrondDescriptor, { operationModel, effectiveByKey, emissions, contractsOf, log }: Assembly): void {
+  log.child(frond.name).info('declared remote — not hosted locally');
+  for (const handler of frond.handlers) {
+    const key = facadeKeyOf(handler.address, handler.surface);
+    const operations = operationModel.forHandler(handler);
+    effectiveByKey.set(key, operations);
+    emissions.note(contractsOf(operations), key);
   }
-  // A child hangs off its parent, so everything the parent registered answers here too and
-  // nothing else has to know: `ScopeContainer.resolve` already walks up. The boot installs
-  // parents first, which is what makes the key below resolvable.
-  const above = frond.extends ? container.resolve<Container>(`frond:${frond.extends}`) : container;
-  const scope = above.createScope();
-  const frondLog = log.child(frond.name);
-  // The frond's own voice, a child of the APP logger and never of `log` — which is the
-  // boot's, so a service's line would have claimed `boot:` long after the boot was over.
-  scope.registerValue('Logger', container.resolve<Logger>('Logger').child(frond.name));
-
-  // `reads:` is what makes a cross-source reader exist here, and the list IS its
-  // environment — a source holding none of these is never opened. Registered under
-  // the type's own name, which is the key `depKeyOf` already derives for a plain
-  // parameter: `constructor(private reads: Reads)` and nothing else to say.
-  // Declaring `reads:` with nothing to build the reader is a boot that ignores a
-  // clause: the handler asking for `Reads` then dies at its first call, on a
-  // container message that names neither the clause nor what is missing.
-  await registerReads(frond, scope, entityByName, options.sourcesFactory, frondLog);
+}
 
-  // Who owns what, and the rule that makes owning mean something. Before anything is
-  // registered, so a bad line is named by this refusal rather than by the container's.
+/**
+ * Who owns what, and the rule that makes owning mean something — refused before anything is
+ * registered, so a bad line is named here rather than by the container.
+ */
+function ownershipOf(frond: FrondDescriptor, { entityByName, refused }: Assembly): Map<string, string> {
   sharedNames(frond, refused);
   refuseArityDrift(frond, refused);
   const owners = ownersOf(frond.providers, frond.name, refused);
   storageInUserCode(frond, owners, (entity) => entityByName.has(entity), refused);
   crudOnOwned(frond, owners, refused);
 
-  const declared = registerProviders(frond, scope, options.ports, boundPorts, refused, frondLog);
-  // An ancestor's links stand OUTSIDE this frond's own, the order `wrapping` reads — and
-  // like a middleware, a link cannot be inherited through a container key, since a seam has
-  // none: its realization is built rather than resolved.
-  const seams = inheritedSeams(frond, assembly.seamsOf, declared);
-  assembly.seamsOf.set(frond.name, seams);
+  return owners;
+}
 
-  // Register Storage for each entity — PascalCase type name (e.g. 'PostStorage')
-  // When a handler declares Crud(Entity, Output), scope the storage via .output(Output)
-  registerStorages(frond, assembly, scope, seams, owners, frondLog);
+/** A frame is read from the same `deps` every port is: asking for one IS declaring it. */
+function registerFramesOf(frond: FrondDescriptor, assembly: Assembly, scope: Container, frondLog: Logger): void {
+  const { entityByName, frondOf, options, hosting, refused } = assembly;
+  const wanted = [...frond.handlers, ...frond.providers, ...frond.presenters, ...frond.collectors]
+    .flatMap((declared) => declared.deps.map((key) => ({ key, filePath: declared.filePath })));
+
+  registerFrames(scope, wanted, frond.providers, {
+    entityByName,
+    frondOf,
+    hostedHere: (name) => !(options.remotes && name in options.remotes),
+    storageFactory: options.storageFactory,
+    sourceOf: options.sourceOf,
+    transacts: options.transacts,
+    transacted: options.transacted,
+    hosting,
+    log: frondLog,
+  }, refused);
+}
 
-  // Frames, after the ORMs and before anything that may ask for one. A frame is read
-  // from the same `deps` every other port is read from — asking for it IS declaring it,
-  // so nothing is registered for a frame nobody wants.
-  registerFrames(
-    scope,
-    [...frond.handlers, ...frond.providers, ...frond.presenters, ...frond.collectors]
-      .flatMap((d) => d.deps.map((key) => ({ key, filePath: d.filePath }))),
-    frond.providers,
-    {
-      entityByName,
-      frondOf,
-      hostedHere: (name) => !(options.remotes && name in options.remotes),
-      storageFactory: options.storageFactory,
-      sourceOf: options.sourceOf,
-      transacts: options.transacts,
-      transacted: options.transacted,
-      hosting: assembly.hosting,
-      log: frondLog,
-    },
-    refused,
-  );
-
-  // Register presenters in scope — PascalCase type name (e.g. 'PostPresenter')
-  const presenterMap = new Map(frond.presenters.map((p) => [p.entityName, p]));
+function registerPresenters(frond: FrondDescriptor, scope: Container, frondLog: Logger): Map<string, PresenterEntry> {
   for (const presenter of frond.presenters) {
     scope.register(presenterKeyOf(presenter.entityName), presenter.ctor, { deps: presenter.deps });
   }
@@ -548,104 +509,117 @@ export async function installFrond(frond: FrondDescriptor, assembly: Assembly):
     frondLog.debug(`${frond.presenters.length} presenter(s): ${frond.presenters.map((p) => p.entityName).join(', ')}`);
   }
 
-  // Register collectors in scope — PascalCase type name (e.g. 'UserCollector')
-  const collectorTypeNames = new Set(frond.collectors.map((c) => c.typeName));
+  return new Map(frond.presenters.map((presenter) => [presenter.entityName, presenter]));
+}
+
+function registerCollectors(frond: FrondDescriptor, scope: Container, frondLog: Logger): Set<string> {
   for (const collector of frond.collectors) {
-    const key = collectorKeyOf(collector.typeName);
-    scope.register(key, collector.ctor, { deps: collector.deps });
+    scope.register(collectorKeyOf(collector.typeName), collector.ctor, { deps: collector.deps });
   }
   if (frond.collectors.length > 0) {
     frondLog.debug(`${frond.collectors.length} collector(s): ${frond.collectors.map((c) => c.typeName).join(', ')}`);
   }
 
-  // Register middlewares in scope, then take them on. Resolved per call and never here:
-  // a middleware asking for something request-scoped would otherwise be handed the one
-  // instance the boot built — the same reason `getMiddlewares` is read at call time.
-  registerMiddlewares(frond, scope, assembly, frondLog);
-
-  // Build handler facades → registered in ROOT container (public contract)
-  const defaultHandlers = frond.handlers.filter((h) => !h.surface);
-  const surfaceHandlers = frond.handlers.filter((h) => h.surface);
-  const defaultHandlerMap = new Map(defaultHandlers.map((h) => [h.address, h]));
+  return new Set(frond.collectors.map((collector) => collector.typeName));
+}
 
-  const building: Building = { frond, assembly, scope, collectorTypeNames, presenterMap, frondLog };
-  const buildFacade = (
-    entity: EntityEntry | undefined,
-    handler: HandlerEntry,
-    targetScope: Container,
-    facadeKey: string,
-  ) => buildFacadeInto(building, entity, handler, targetScope, facadeKey);
-
-  // A presenter is about an entity — computed fields sit on a shape — so this walks
-  // entities. Exposing the instance lazily; the bridge resolves it on first access.
-  exposePresenters(frond, presenterMap, container, scope);
+function sayFacade(building: Building, facadeKey: string, entity: EntityEntry | undefined): void {
+  const operations = Object.keys(building.assembly.container.resolve(facadeKey) as object).join(', ');
+  building.frondLog.debug(`${facadeKey} [${operations}]`
+    + (entity ? '' : ' — no entity of that name: no storage, no projection, no presenter'));
+}
 
-  // A facade is about a handler, so this walks HANDLERS. It walked entities before,
-  // which made an entity a precondition for being callable at all: a handler naming
-  // none was scanned, then never built, and nothing said so.
-  for (const handler of defaultHandlers) {
-    // Two ways to know the subject, and the explicit one wins: `Crud(Item)` names the
-    // entity it was built on, whatever the handler is called. Otherwise the handler's
-    // own name is the only thing pointing at one — and pointing at nothing is legal.
-    //
-    // By NAME, not by identity: the scanner loads an entity through its own loader and
-    // the handler imports it through the runtime's, so the same class arrives as two
-    // objects. `===` compares module instances, which is not the question being asked.
+/**
+ * A facade is about a handler, so this walks HANDLERS — pointing at no entity is legal. The
+ * subject is `Crud(Item)`'s when it names one, the handler's own name otherwise, compared by
+ * NAME: the scanner and the runtime load one class as two objects.
+ */
+function buildDefaultFacades(building: Building, handlers: readonly HandlerEntry[]): void {
+  for (const handler of handlers) {
     const crudTarget = targetOf(handler.ctor);
     const subject = crudTarget?.name ? lowerFirst(crudTarget.name) : handler.address;
-    const entity = frond.entities.find((e) => e.name === subject);
+    const entity = building.frond.entities.find((e) => e.name === subject);
     const facadeKey = facadeKeyOf(handler.address);
-    buildFacade(entity, handler, scope, facadeKey);
-    frondLog.debug(`${facadeKey} [${Object.keys(container.resolve(facadeKey) as object).join(', ')}]`
-      + (entity ? '' : ' — no entity of that name: no storage, no projection, no presenter'));
+    buildFacadeInto(building, entity, handler, building.scope, facadeKey);
+    sayFacade(building, facadeKey, entity);
   }
+}
 
-  // The dual, and it stays: a shape that declares no operation answers nothing. Said
-  // once per entity rather than deduced from a silence.
-  for (const entity of frond.entities) {
-    if (!defaultHandlerMap.has(entity.name)) {
-      frondLog.debug(`${entity.name} — entity only, no handler: exposes nothing`);
-    }
+/** A shape that declares no operation answers nothing — said once per entity rather than deduced from a silence. */
+function sayUnhandledEntities(building: Building, handlers: readonly HandlerEntry[]): void {
+  const handled = new Set(handlers.map((handler) => handler.address));
+  for (const entity of building.frond.entities) {
+    if (!handled.has(entity.name)) building.frondLog.debug(`${entity.name} — entity only, no handler: exposes nothing`);
   }
+}
 
-  // Surface handlers — create sub-scope per surface handler with scoped storage
-  //
-  // Pointing at nothing is legal HERE TOO. This loop used to `continue` when no entity
-  // carried the handler's name, so `handlers/public/SearchHandler.ts` with no `Search`
-  // entity got no facade at all and no line saying why — while the very same handler at
-  // the default surface is built and logged. One rule, both surfaces.
-  for (const handler of surfaceHandlers) {
-    const entity = frond.entities.find((e) => e.name === handler.address);
-    const surfaceScope = scope.createScope();
-
-    // Register scoped storage if output override differs from entity — under the REPOSITORY
-    // key, which is what a Crud handler asks for, and under the port's own for a holder
-    // that legitimately names it. Registering only the latter left a named surface with
-    // no facade at all once the façade stopped spelling the storage.
-    if (entity) registerSurfaceStorage(entity, handler, surfaceScope, assembly, frondLog);
+/**
+ * One sub-scope per surface handler, holding the storage its view scopes — under the REPOSITORY
+ * key a Crud handler asks for. Pointing at no entity is legal here too: one rule, both surfaces.
+ */
+function buildSurfaceFacades(building: Building, handlers: readonly HandlerEntry[]): void {
+  for (const handler of handlers) {
+    const entity = building.frond.entities.find((e) => e.name === handler.address);
+    const surfaceScope = building.scope.createScope();
+    if (entity) registerSurfaceStorage(entity, handler, surfaceScope, building.assembly, building.frondLog);
 
     const facadeKey = facadeKeyOf(handler.address, handler.surface);
-    buildFacade(entity, handler, surfaceScope, facadeKey);
-    frondLog.debug(`${facadeKey} [${Object.keys(container.resolve(facadeKey) as object).join(', ')}]`
-      + (entity ? '' : ' — no entity of that name: no storage, no projection, no presenter'));
+    buildFacadeInto(building, entity, handler, surfaceScope, facadeKey);
+    sayFacade(building, facadeKey, entity);
   }
+}
 
-  // A named surface is closed, so what it contains is a fact worth stating.
-  // Saying it at boot is the difference between a rule and a rule you can
-  // check: an entity you meant to serve and never wrote a handler for is
-  // absent HERE, in one line, instead of being discovered missing later.
-  const surfaceNames = [...new Set(surfaceHandlers.map((h) => h.surface as string))].sort();
+/** A named surface is closed, so what it serves — and what it leaves out — is said at boot, in one line. */
+function sayWhatSurfacesServe(frond: FrondDescriptor, handlers: readonly HandlerEntry[], frondLog: Logger): void {
+  const surfaceNames = [...new Set(handlers.map((h) => h.surface as string))].sort();
   for (const surfaceName of surfaceNames) {
-    const served = surfaceHandlers
-      .filter((h) => h.surface === surfaceName)
-      .map((h) => h.address)
-      .sort();
+    const served = handlers.filter((h) => h.surface === surfaceName).map((h) => h.address).sort();
     const absent = frond.entities.map((e) => e.name).filter((n) => !served.includes(n));
     frondLog.info(
       `surface '${surfaceName}' — ${served.length} entit${served.length === 1 ? 'y' : 'ies'}: ${served.join(', ')}` +
       (absent.length > 0 ? ` (not served: ${absent.join(', ')})` : ''),
     );
   }
+}
+
+export async function installFrond(frond: FrondDescriptor, assembly: Assembly): Promise<void> {
+  const { container, entityByName, options, log } = assembly;
+
+  if (options.remotes && frond.name in options.remotes) {
+    noteRemoteFrond(frond, assembly);
+
+    return;
+  }
+
+  // A child hangs off its parent, so what the parent registered answers here too — parents are installed first.
+  const above = frond.extends ? container.resolve<Container>(`frond:${frond.extends}`) : container;
+  const scope = above.createScope();
+  const frondLog = log.child(frond.name);
+  // A child of the APP logger, never of the boot's, whose `boot:` would outlive the boot.
+  scope.registerValue('Logger', container.resolve<Logger>('Logger').child(frond.name));
+
+  await registerReads(frond, scope, entityByName, options.sourcesFactory, frondLog);
+  const owners = ownershipOf(frond, assembly);
+
+  const declared = registerProviders(frond, scope, options.ports, assembly.boundPorts, assembly.refused, frondLog);
+  // An ancestor's links stand OUTSIDE this frond's own; a seam has no container key to inherit through.
+  const seams = inheritedSeams(frond, assembly.seamsOf, declared);
+  assembly.seamsOf.set(frond.name, seams);
+  registerStorages(frond, assembly, scope, seams, owners, frondLog);
+  registerFramesOf(frond, assembly, scope, frondLog);
+
+  const presenterMap = registerPresenters(frond, scope, frondLog);
+  const collectorTypeNames = registerCollectors(frond, scope, frondLog);
+  registerMiddlewares(frond, scope, assembly, frondLog);
+  exposePresenters(frond, presenterMap, container, scope);
+
+  const building: Building = { frond, assembly, scope, collectorTypeNames, presenterMap, frondLog };
+  const defaultHandlers = frond.handlers.filter((h) => !h.surface);
+  const surfaceHandlers = frond.handlers.filter((h) => h.surface);
+  buildDefaultFacades(building, defaultHandlers);
+  sayUnhandledEntities(building, defaultHandlers);
+  buildSurfaceFacades(building, surfaceHandlers);
+  sayWhatSurfacesServe(frond, surfaceHandlers, frondLog);
 
   container.registerValue(`frond:${frond.name}`, scope);
   frondLog.info(`registered — ${frond.entities.length} entities, ${frond.handlers.length} handlers, ${frond.seeds.length} seeds`);

package/src/boot/relations.ts

@@ -4,7 +4,7 @@ import type { Dependent } from '../dispatch/Dependent.js';
 import type { RelationCheck } from '../dispatch/RelationCheck.js';
 import type { Hosting } from './Hosting.js';
 import type { Diagnostic } from '../diagnostic.js';
-import type { Releasing, Rows } from '../dispatch/Release.js';
+import type { Releasing } from '../dispatch/Release.js';
 import type { EntityEntry } from '../descriptor/EntityEntry.js';
 
 /**
@@ -44,11 +44,6 @@ function referencesTo(target: string, hosting: Hosting): { entity: string; field
   return found;
 }
 
-/** What a target's storage has to answer for a key set to be judged in one read. */
-interface ByKeys {
-  findByKeys(keys: readonly string[]): Promise<Map<string, unknown>>;
-}
-
 /**
  * The references a foreign key cannot hold, each as a read the guard makes before the write.
  *
@@ -68,7 +63,7 @@ export function heldBy(entity: SchemaView, name: string, hosting: Hosting): Rela
       field,
       target,
       missing: async (keys) => {
-        const storage = hosting.storageOf(target) as ByKeys | undefined;
+        const storage = hosting.storageOf(target);
         // Nothing here holds those rows — the process that does answers the same reading,
         // so the question crosses rather than being given up on.
         if (!storage) return hosting.peerOf(target)?.missing(target, keys) ?? [];
@@ -176,7 +171,7 @@ export function unheldAmong(checks: readonly RelationCheck[], hosting: Hosting):
 export function releasing(hosting: Hosting): Releasing {
   return {
     dependentsOf: (entity) => dependentsOf(entity, hosting),
-    rowsOf: (entity) => hosting.storageOf(entity) as Rows | undefined,
+    rowsOf: (entity) => hosting.storageOf(entity),
     schemaOf: (entity) => hosting.entities().get(entity),
     peers: () => hosting.peers(),
     journal: (entity) => hosting.journal(entity),

package/src/boot/seed.ts

@@ -67,7 +67,7 @@ function whatEachWaitsFor(
 /** Where a seed writes, and what it may skip — resolved per entity. */
 interface SeedFacade {
   list(): Promise<unknown[]>;
-  write(item: unknown): Promise<unknown>;
+  write(item: Record<string, unknown>): Promise<unknown>;
 }
 
 /**
@@ -126,9 +126,7 @@ function facadeFor(app: App, entityName: string): SeedFacade | undefined {
     };
   }
 
-  const storage = app.storageFor(entityName) as
-    | { list: () => Promise<unknown[]>; create: (input: unknown) => Promise<unknown> }
-    | undefined;
+  const storage = app.storageFor(entityName);
   if (!storage) return undefined;
 
   return { list: () => storage.list(), write: (item) => storage.create(item) };

package/src/descriptor/Fronds.ts

@@ -41,6 +41,16 @@ export class Fronds extends Array<FrondDescriptor> {
     return this.flatMap((frond) => frond.entities.map((e) => e.name)).sort();
   }
 
+  /**
+   * Whether a named surface serves an entity, as its owning frond declared it — `undefined` when
+   * that frond declares no such surface, and a facade registered there answers as it is.
+   */
+  admits(surface: string, entity: string): boolean | undefined {
+    const declared = this.owner(entity)?.surfaces?.[surface];
+
+    return declared?.some((name) => name.toLowerCase() === entity.toLowerCase());
+  }
+
   /** The names a call may address, sorted — what a NOT_FOUND must print. */
   servedNames(surface?: string): string[] {
     return this.flatMap((frond) => frond.handlers

package/src/descriptor/index.ts

@@ -23,6 +23,7 @@ export { type TypeRef } from '../wire/TypeRef.js';
 export { computeBindingPlan, type BindingPlan } from '../wire/binding.js';
 export type { Signature } from '../wire/Signature.js';
 export { awaitKeyOf, emitKeyOf } from '../wire/Emit.js';
+export { addressOf } from '../wire/Facade.js';
 export { storageKeyOf } from '../storage/Storage.js';
 export { getPresenterFields } from '../prefab/presenter.js';
 export { targetOf, viewsOf, outputOf } from '../prefab/prefab.js';

package/src/dispatch/InFlight.ts

@@ -36,11 +36,25 @@ export class InFlight {
     };
   }
 
-  close(): void {
+  /** Close the door, and answer once the calls already running are done — or refuse at the deadline, naming what is left. */
+  async drain(timeoutMs?: number): Promise<void> {
     this.accepting = false;
+    if (timeoutMs === undefined) return this.whenIdle();
+
+    let timer: ReturnType<typeof setTimeout>;
+
+    await Promise.race([
+      this.whenIdle().then(() => clearTimeout(timer)),
+      new Promise<never>((_, reject) => {
+        timer = setTimeout(
+          () => reject(new Error(`[drain] ${this.running} call(s) still running after ${timeoutMs}ms`)),
+          timeoutMs,
+        );
+      }),
+    ]);
   }
 
-  whenIdle(): Promise<void> {
+  private whenIdle(): Promise<void> {
     if (this.running === 0) return Promise.resolve();
 
     return new Promise((resolve) => this.idle.push(resolve));

package/src/index.ts

@@ -91,7 +91,7 @@ export type { FougereOperations } from './wire/FougereOperations.js';
 export type { HandlerOf } from './wire/HandlerOf.js';
 export type { Refused } from './wire/Refused.js';
 export type { Rows } from './wire/Rows.js';
-export type { Facade } from './wire/Facade.js';
+export { addressOf, type Facade } from './wire/Facade.js';
 export type {
   FrondCall,
   Transport,
@@ -150,9 +150,7 @@ export type { PresenterEntry } from './descriptor/PresenterEntry.js';
 export type { PresenterFieldMeta } from './descriptor/PresenterFieldMeta.js';
 export type { ProviderEntry } from './descriptor/ProviderEntry.js';
 export type { SeedEntry } from './descriptor/SeedEntry.js';
-export type { AuthConfig } from './boot/AuthConfig.js';
-export type { AuthContext } from './boot/AuthContext.js';
-export type { AuthRuntime } from './boot/AuthRuntime.js';
+export { AUTH, type AuthRuntime } from './boot/AuthRuntime.js';
 export { Fronds } from './descriptor/Fronds.js';
 export { verify, type Misplaced } from './verify.js';
 // Same question as verify(), answered from the source text instead of the model.

package/src/node.ts

@@ -1,6 +1,6 @@
 /** What Fougere does with a filesystem, minus the scan — that is `@fougere/compiler`. */
 export { setModuleLoader, getModuleLoader } from './loader.js';
-export { loadConfig, loadCascadedConfig, remotesOf } from './FougereConfig.js';
+export { configFileIn, loadConfig, loadCascadedConfig, remotesOf } from './FougereConfig.js';
 export { statedModules } from './StatedModules.js';
 export { defineFrond, loadFrondConfig } from './FrondConfig.js';
 

package/src/prefab/CrudConstructor.ts

@@ -1,10 +1,8 @@
 import { lowerFirst, type EntityConstructor, type SchemaView } from '@fougere/schema';
 import type { ListOptions } from '../storage/ListOptions.js';
-import type { ListResult } from '../storage/ListResult.js';
 import type { Storage } from '../storage/Storage.js';
 import type { OperationContract } from '../wire/OperationContract.js';
 import { targetOf } from './prefab.js';
-import type { CrudOpName } from './CrudOpName.js';
 import type { CrudViews } from './CrudViews.js';
 import { pageOf, type Page } from '../wire/Page.js';
 import type { CrudOps } from './CrudOps.js';
@@ -88,15 +86,6 @@ function asCrudConstructor<T, V>(impl: object): CrudConstructor<T, V> {
   return impl as CrudConstructor<T, V>;
 }
 
-/** The view an op emits, fabricated. */
-type OutOf<V, K extends CrudOpName, T> =
-  // Bracketed on purpose: a naked `V extends …` DISTRIBUTES, and the no-view default
-  // is the empty map, whose `keyof` is `never` — distribution would then collapse
-  // every op's output to `never` instead of falling through to the entity.
-  [V] extends [EntityConstructor] ? InstanceType<V & EntityConstructor>
-  : K extends keyof V ? (V[K] extends EntityConstructor ? InstanceType<V[K]> : T)
-  : T;
-
 /** The prefab handler class — its ops, plus the statics the bootstrap and adapters read. */
 export interface CrudConstructor<T, V = {}> {
   // `Storage<T>`, not the bare `Storage`: a handler that injects a second storage has to

package/src/storage/Comparison.ts

@@ -1,5 +1,4 @@
 import { type Field, Shapes } from '@fougere/schema';
-import type { ComparisonName } from './ComparisonName.js';
 
 /**
  * The comparisons a criterion may name.
@@ -21,7 +20,11 @@ export interface Comparison {
   isNull?: boolean;
 }
 
-export const COMPARISONS = ['gte', 'lte', 'gt', 'lt', 'ne', 'between', 'contains', 'notIn', 'isNull'] as const;
+export type ComparisonName = keyof Comparison;
+
+export const COMPARISONS = Object.keys({
+  gte: true, lte: true, gt: true, lt: true, ne: true, between: true, contains: true, notIn: true, isNull: true,
+} satisfies Record<ComparisonName, true>);
 
 /**
  * Is this criterion a comparison, or a value that happens to be an object?
@@ -42,11 +45,11 @@ export function comparisonOf(field: Field | undefined, asked: unknown): Comparis
 /** The comparisons a criterion names, in the order the caller wrote them. */
 export function comparisonsIn(comparison: Comparison): [ComparisonName, unknown][] {
   return Object.entries(comparison).filter(
-    (entry): entry is [ComparisonName, unknown] => (COMPARISONS as readonly string[]).includes(entry[0]),
+    (entry): entry is [ComparisonName, unknown] => COMPARISONS.includes(entry[0]),
   );
 }
 
 /** What a comparison names that this vocabulary does not — a typo, said as one. */
 export function unknownIn(comparison: Comparison): string[] {
-  return Object.keys(comparison).filter((name) => !(COMPARISONS as readonly string[]).includes(name));
+  return Object.keys(comparison).filter((name) => !COMPARISONS.includes(name));
 }

package/src/wire/Emit.ts

@@ -35,7 +35,7 @@ export function factOfEmitKey(key: string): string | undefined {
 }
 
 /** The fact behind an awaited emission's key — the dual, read the same way. */
-export function factOfAwaitKey(key: string): string | undefined {
+function factOfAwaitKey(key: string): string | undefined {
   return behind(key, AWAIT_SUFFIX);
 }
 

package/src/wire/Facade.ts

@@ -1,14 +1,6 @@
-import type { InvocationContext } from './InvocationContext.js';
-import type { FougereOperations } from './FougereOperations.js';
-
-type Served = keyof FougereOperations & string;
+import { lowerFirst } from '@fougere/schema';
 
-/**
- * Both halves below take the union through a type PARAMETER, which is what makes the
- * conditional distribute: `Served` is an alias, and an alias is matched whole — `'a.x' | 'b.y'`
- * does not extend `` `${string}.${string}` `` as one thing, so the naive form answers `never`.
- */
-type AddressIn<Key> = Key extends `${infer Address}.${string}` ? Address : never;
+import type { InvocationContext } from './InvocationContext.js';
 
 /**
  * The facade built in front of a handler — the framework's second port, after `Storage`.
@@ -34,6 +26,21 @@ export function facadeKeyOf(entityName: string, surface?: string): string {
   return surface ? `${surface}:${entityName}Handler` : `${entityName}Handler`;
 }
 
+/**
+ * The address a handler answers at, read off its class name or its facade key — the dual of
+ * `facadeKeyOf`. `PostHandler` → `post`, `postHandler` → `post`.
+ */
+export function addressOf(name: string): string {
+  return lowerFirst(name.endsWith(HANDLER) ? name.slice(0, -HANDLER.length) : name);
+}
+
+/** A default facade's key — `postHandler`, never `admin:postHandler` nor `PostStorage`. */
+export function isFacadeKey(key: string): boolean {
+  return key.endsWith(HANDLER) && !key.includes(':');
+}
+
+const HANDLER = 'Handler';
+
 /** Where the contracts behind a façade live — the dual of `facadeKeyOf`. */
 export function contractsKeyOf(entityName: string, surface?: string): string {
   return `${facadeKeyOf(entityName, surface)}:contracts`;

package/src/wire/OperationContract.ts

@@ -117,7 +117,7 @@ export function inferOperationKind(name: string): OperationKindInference {
 }
 
 /** Explicit config is authoritative; otherwise the finite convention may decline. */
-export function resolveOperationKind(
+function resolveOperationKind(
   name: string,
   overrides?: Record<string, { kind?: OperationKind }>,
 ): OperationKind | undefined {

package/src/wire/OperationsMap.ts

@@ -1,14 +1,4 @@
-import type { Param } from './Param.js';
-import type { TypeRef } from './TypeRef.js';
 import type { OperationContract } from './OperationContract.js';
 
 /** Map of operation name → its contract. */
 export type OperationsMap = Map<string, OperationContract>;
-
-export type { TypeRef, Param };
-
-// ─── Operation intent (read vs write) ──────────
-// Naming convention for inferred handlers — scheduled to die with the
-// handler-kind plan (docs/notes/handler-kind.md). Lives here, NOT in
-// @fougere/schema: it is a runtime convention about operations, not a
-// schema concept.

package/dist/boot/AuthConfig.d.ts

@@ -1,14 +0,0 @@
-import type { SchemaView } from '@fougere/schema';
-import type { AuthContext } from './AuthContext.js';
-import type { AuthRuntime } from './AuthRuntime.js';
-/** Lazy auth declaration written in fougere.config.ts. */
-export interface AuthConfig {
-    /** Build the runtime — invoked by createApp at boot with the resolved storage handles. */
-    create(ctx: AuthContext): AuthRuntime | Promise<AuthRuntime>;
-    /**
-     * Entities the provider will use. Optional metadata — useful for the core's
-     * future migration registry to know which tables auth needs.
-     */
-    entities?: Record<string, SchemaView>;
-}
-//# sourceMappingURL=AuthConfig.d.ts.map

package/dist/boot/AuthConfig.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AuthConfig.d.ts","sourceRoot":"","sources":["../../src/boot/AuthConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,0DAA0D;AAC1D,MAAM,WAAW,UAAU;IACzB,0FAA0F;IAC1F,MAAM,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IAC7D;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CACvC"}

package/dist/boot/AuthConfig.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=AuthConfig.js.map

package/dist/boot/AuthConfig.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AuthConfig.js","sourceRoot":"","sources":["../../src/boot/AuthConfig.ts"],"names":[],"mappings":""}