@fougere/core 0.10.0-alpha.0 → 0.12.0-alpha.0

package/src/boot/remote.ts

@@ -65,36 +65,9 @@ export function createRemoteRouter(
 
     for (const answered of cards) {
       if (!answered) continue;
-      const { label, url, transport, answer } = answered;
-      pending.delete(label);
-      const card = assertIdentityCard(answer, `Remote '${label}' (${url})`);
 
-      for (const frond of card.fronds) {
-        // Facades only. A fact is not routable — nobody calls it, it arrives — so
-        // adding one here would answer a call with a transport to a facade that
-        // does not exist.
-        for (const facade of frond.facades) {
-          const first = claimedBy.get(facade.name);
-          /** Two remotes claiming one name is refused, not silently arbitrated. */
-          if (first !== undefined && first !== label) {
-            throw new FougereError({
-              code: ErrorCode.INTERNAL_ERROR,
-              message:
-                `[claim] Two remotes serve '${facade.name}': '${first}' and '${label}'.\n`
-                + `  A call names an entity, not a frond, so nothing could choose between them.\n`
-                + `  - Keep one of the two out of \`remotes:\`, or\n`
-                + `  - expose one of them under a different entity name.`,
-              entity: facade.name,
-            });
-          }
-          claimedBy.set(facade.name, label);
-          byEntity.set(facade.name, {
-            frond: frond.name,
-            transport,
-            ...(facade.schema ? { schema: Card.fromDescriptor(facade.schema as SchemaDescriptor).toSchema() } : {}),
-          });
-        }
-      }
+      pending.delete(answered.label);
+      claimFacades(answered, byEntity, claimedBy);
     }
   };
 
@@ -141,3 +114,48 @@ export function createRemoteFacade(
 
   return dynamicOperations(opFn) as Facade;
 }
+
+/** What one remote answered `discover` with, once it has been reached. */
+interface Answered {
+  label: string;
+  url: string;
+  transport: Transport;
+  answer: unknown;
+}
+
+/**
+ * Which remote serves which facade. Facades only: a fact is not routable — nobody calls it, it
+ * arrives — so adding one here would answer a call with a transport to a facade that does not
+ * exist. Two remotes claiming one name is refused, never silently arbitrated.
+ */
+function claimFacades(
+  { label, url, transport, answer }: Answered,
+  byEntity: Map<string, Route>,
+  claimedBy: Map<string, string>,
+): void {
+  const card = assertIdentityCard(answer, `Remote '${label}' (${url})`);
+
+  for (const frond of card.fronds) {
+    for (const facade of frond.facades) {
+      const first = claimedBy.get(facade.name);
+      if (first !== undefined && first !== label) {
+        throw new FougereError({
+          code: ErrorCode.INTERNAL_ERROR,
+          message:
+            `[claim] Two remotes serve '${facade.name}': '${first}' and '${label}'.\n`
+            + `  A call names an entity, not a frond, so nothing could choose between them.\n`
+            + `  - Keep one of the two out of \`remotes:\`, or\n`
+            + `  - expose one of them under a different entity name.`,
+          entity: facade.name,
+        });
+      }
+
+      claimedBy.set(facade.name, label);
+      byEntity.set(facade.name, {
+        frond: frond.name,
+        transport,
+        ...(facade.schema ? { schema: Card.fromDescriptor(facade.schema as SchemaDescriptor).toSchema() } : {}),
+      });
+    }
+  }
+}

package/src/boot/seed.ts

@@ -15,6 +15,33 @@ export interface SeedOrder {
 
 /** Seeds in dependency order — a `ref()` target is planted before its referrer. */
 export function orderSeeds(fronds: FrondDescriptor[]): SeedOrder {
+  const seeds = fronds.flatMap((frond) => frond.seeds);
+  const waiting = whatEachWaitsFor(fronds, seeds);
+
+  const ordered: SeedEntry[] = [];
+  const planted = new Set<string>();
+
+  while (waiting.size > 0) {
+    const ready = [...waiting.keys()].find((seed) => [...waiting.get(seed)!].every((dep) => planted.has(dep)));
+    if (!ready) break;
+
+    ordered.push(ready);
+    planted.add(ready.entityName.toLowerCase());
+    waiting.delete(ready);
+  }
+
+  return { ordered, cycle: [...waiting.keys()] };
+}
+
+/**
+ * Only what is actually SEEDED can be waited for: a relation to an entity with no seed is
+ * already satisfied by whatever put its rows there, and an entity naming itself waits for
+ * nobody.
+ */
+function whatEachWaitsFor(
+  fronds: FrondDescriptor[],
+  seeds: SeedEntry[],
+): Map<SeedEntry, Set<string>> {
   const refs = new Map<string, Set<string>>();
   for (const frond of fronds) {
     for (const entity of frond.entities) {
@@ -28,33 +55,13 @@ export function orderSeeds(fronds: FrondDescriptor[]): SeedOrder {
     }
   }
 
-  const seeds = fronds.flatMap((frond) => frond.seeds);
   const seeded = new Set(seeds.map((seed) => seed.entityName.toLowerCase()));
 
-  // Only what is actually seeded can be waited for: a relation to an entity with no seed
-  // is already satisfied by whatever put its rows there.
-  const waiting = new Map(
-    seeds.map((seed) => {
-      const own = seed.entityName.toLowerCase();
-      const targets = [...(refs.get(own) ?? [])].filter((target) => seeded.has(target) && target !== own);
+  return new Map(seeds.map((seed) => {
+    const own = seed.entityName.toLowerCase();
 
-      return [seed, new Set(targets)] as const;
-    }),
-  );
-
-  const ordered: SeedEntry[] = [];
-  const planted = new Set<string>();
-
-  while (waiting.size > 0) {
-    const ready = [...waiting.keys()].find((seed) => [...waiting.get(seed)!].every((dep) => planted.has(dep)));
-    if (!ready) break;
-
-    ordered.push(ready);
-    planted.add(ready.entityName.toLowerCase());
-    waiting.delete(ready);
-  }
-
-  return { ordered, cycle: [...waiting.keys()] };
+    return [seed, new Set([...(refs.get(own) ?? [])].filter((target) => seeded.has(target) && target !== own))] as const;
+  }));
 }
 
 /** Where a seed writes, and what it may skip — resolved per entity. */
@@ -110,10 +117,12 @@ function facadeFor(app: App, entityName: string): SeedFacade | undefined {
   let handler: Record<string, Function> | undefined;
   try { handler = app.resolve<Record<string, Function>>(facadeKeyOf(entityName)); } catch {}
 
-  if (typeof handler?.list === 'function' && typeof handler.create === 'function') {
+  const list = handler?.list;
+  const create = handler?.create;
+  if (typeof list === 'function' && typeof create === 'function') {
     return {
-      list: () => handler!.list() as Promise<unknown[]>,
-      write: (item) => handler!.create({ params: {}, query: {}, input: item, state: {} }),
+      list: () => list.call(handler) as Promise<unknown[]>,
+      write: (item) => create.call(handler, { params: {}, query: {}, input: item, state: {} }),
     };
   }
 

package/src/boot/together.ts

@@ -11,6 +11,8 @@ import { type StorageFactory } from '../storage/StorageFactory.js';
 import type { Logger } from '../builtin/Logger.js';
 import type { ProviderEntry } from '../descriptor/ProviderEntry.js';
 import { StorageGuard } from '../dispatch/StorageGuard.js';
+import { heldBy, releasing } from './relations.js';
+import type { Hosting } from './Hosting.js';
 import { recording, unwind, type Undo } from './frame.js';
 import type { Diagnostic } from '../diagnostic.js';
 
@@ -26,6 +28,8 @@ export interface FrameWorld {
   /** Whether that source hands one out — asked before the frame is built, not at the call. */
   transacts?: (source: string) => boolean;
   transacted?: <R>(source: string, fn: (storageFactory: StorageFactory) => Promise<R>) => Promise<R>;
+  /** What a member's references ask before a write — the answer its frond's own storage gets. */
+  hosting: Hosting;
   log: Logger;
 }
 
@@ -44,42 +48,59 @@ function resolve(
   refused: Diagnostic[],
 ): Members | undefined {
   const before = refused.length;
+  const entities = entitiesNamed(names.entities, world, asked, refused);
+  const providers = providersNamed(names.providers, declared, asked, refused);
 
-  const entities = names.entities.flatMap((member) => {
+  return refused.length === before ? { entities, providers } : undefined;
+}
+
+/** The first list names ENTITIES — a class of this frond goes in the second. */
+function entitiesNamed(
+  named: readonly string[],
+  world: FrameWorld,
+  asked: Asked,
+  refused: Diagnostic[],
+): { name: string; schema: SchemaView }[] {
+  return named.flatMap((member) => {
     const name = lowerFirst(member);
     const schema = world.entityByName.get(name);
-    if (!schema) {
-      refused.push({
-        ...asked,
-        code: 'together-entity-unknown',
-        message: `Together<[…${member}…]>: no entity named '${member}' is scanned in this app. `
-          + 'The first list names entities; a class of this frond goes in the second.',
-      });
+    if (schema) return [{ name, schema }];
 
-      return [];
-    }
+    refused.push({
+      ...asked,
+      code: 'together-entity-unknown',
+      message: `Together<[…${member}…]>: no entity named '${member}' is scanned in this app. `
+        + 'The first list names entities; a class of this frond goes in the second.',
+    });
 
-    return [{ name, schema }];
+    return [];
   });
+}
 
-  const providers = names.providers.flatMap((member) => {
+/**
+ * The second list names the classes to REBUILD inside the frame — a service, a mirror, a
+ * repository — so that what they write is covered by the unwind.
+ */
+function providersNamed(
+  named: readonly string[],
+  declared: readonly ProviderEntry[],
+  asked: Asked,
+  refused: Diagnostic[],
+): ProviderEntry[] {
+  return named.flatMap((member) => {
     const entry = declared.find((provider) => provider.ctor.name === member);
-    if (!entry) {
-      refused.push({
-        ...asked,
-        code: 'together-provider-unknown',
-        message: `Together<[…], [… ${member} …]>: this frond declares no class named '${member}'. `
-          + 'The second list names providers to rebuild inside the frame — a service, a mirror, '
-          + 'a repository — so that what they write is covered by the unwind.',
-      });
+    if (entry) return [entry];
 
-      return [];
-    }
+    refused.push({
+      ...asked,
+      code: 'together-provider-unknown',
+      message: `Together<[…], [… ${member} …]>: this frond declares no class named '${member}'. `
+        + 'The second list names providers to rebuild inside the frame — a service, a mirror, '
+        + 'a repository — so that what they write is covered by the unwind.',
+    });
 
-    return [entry];
+    return [];
   });
-
-  return refused.length === before ? { entities, providers } : undefined;
 }
 
 /** Who asked for the frame, and where they wrote it — the same three fields every refusal here carries. */
@@ -156,11 +177,14 @@ export function registerFrames(
 ): void {
   let registered = 0;
   const seen = new Set<string>();
+
   for (const { key, filePath } of wanted) {
     if (seen.has(key)) continue;
     seen.add(key);
+
     const names = membersOfTogetherKey(key);
     if (!names) continue;
+
     registered += 1;
     const asked = { severity: 'blocking', filePath, subject: key } as const;
     if (!world.storageFactory) {
@@ -175,47 +199,12 @@ export function registerFrames(
     const members = resolve(names, providers, world, asked, refused);
     // Nothing left to build a frame out of, and the refusals above already say what is missing.
     if (!members) continue;
+
     remoteMembers(members, world, asked, refused);
     uncoveredWrites(members, world, asked, refused);
-
-    const sources = new Set(members.entities.map((member) => world.sourceOf?.(member.name) ?? 'db'));
-    const validator = (storage: Storage, name: string, schema: SchemaView) =>
-      new StorageGuard(schema.getFields(), name).guard(storage);
-
-    // One engine and a way into it: the engine gives the unwind AND the isolation. The
-    // question goes to the source these members live in — a composition answering for the
-    // default one would compensate a frame whose own engine holds transactions.
-    const source = sources.size === 1 ? [...sources][0]! : undefined;
-    if (world.transacted && source !== undefined && (world.transacts?.(source) ?? true)) {
-      world.log.info(`${key} — transaction, source '${source}'`);
-      scope.registerValue(key, {
-        run: <R>(fn: (entities: never, providers: never) => Promise<R>) =>
-          ambient.enterFrame(key, () =>
-            world.transacted!(source, (factory) => inScope(scope, members, factory, validator, fn as never))),
-      });
-      continue;
-    }
-
-    // Split, or an engine that hands out no transaction: the frame keeps the before-image
-    // of every write and replays the inverses itself. `validator` stays OUTSIDE `recording`, so
-    // a write the entity refuses never enters the journal.
-    const why = sources.size > 1
-      ? members.entities.map((m) => `${m.name} in '${world.sourceOf?.(m.name) ?? 'db'}'`).join(', ')
-      : 'this storage hands out no transaction';
-    world.log.info(`${key} — compensated: ${why} — no isolation`);
-    scope.registerValue(key, {
-      run: <R>(fn: (entities: never, providers: never) => Promise<R>): Promise<R> => ambient.enterFrame(key, async () => {
-        const journal: Undo[] = [];
-        const record = (storage: Storage, name: string, schema: SchemaView) =>
-          validator(recording(storage, name, schema, journal), name, schema);
-        try {
-          return await inScope(scope, members, world.storageFactory!, record, fn as never);
-        } catch (cause) {
-          return unwind(journal, cause, world.log);
-        }
-      }),
-    });
+    scope.registerValue(key, frameOver(key, members, scope, world));
   }
+
   if (registered > 0 && ambient.degraded) {
     world.log.warn(
       'no async context on this runtime — frames run one at a time, and a frame opened '
@@ -223,3 +212,53 @@ export function registerFrames(
     );
   }
 }
+
+/**
+ * A transaction when one engine holds every member, a compensation otherwise.
+ *
+ * One engine and a way into it: the engine gives the unwind AND the isolation. The question goes
+ * to the SOURCE these members live in — a composition answering for the default one would
+ * compensate a frame whose own engine holds transactions.
+ */
+function frameOver(key: string, members: Members, scope: Container, world: FrameWorld): Frame {
+  const sources = new Set(members.entities.map((member) => world.sourceOf?.(member.name) ?? 'db'));
+  const validator = (storage: Storage, name: string, schema: SchemaView) =>
+    new StorageGuard(schema.getFields(), name, {}, heldBy(schema, name, world.hosting), releasing(world.hosting)).guard(storage);
+
+  const source = sources.size === 1 ? [...sources][0]! : undefined;
+  if (world.transacted && source !== undefined && (world.transacts?.(source) ?? true)) {
+    world.log.info(`${key} — transaction, source '${source}'`);
+
+    return {
+      run: <R>(fn: (entities: never, providers: never) => Promise<R>) =>
+        ambient.enterFrame(key, () =>
+          world.transacted!(source, (factory) => inScope(scope, members, factory, validator, fn as never))),
+    };
+  }
+
+  // Split, or an engine that hands out no transaction: the frame keeps the before-image of every
+  // write and replays the inverses itself. `validator` stays OUTSIDE `recording`, so a write the
+  // entity refuses never enters the journal.
+  const why = sources.size > 1
+    ? members.entities.map((one) => `${one.name} in '${world.sourceOf?.(one.name) ?? 'db'}'`).join(', ')
+    : 'this storage hands out no transaction';
+  world.log.info(`${key} — compensated: ${why} — no isolation`);
+
+  return {
+    run: <R>(fn: (entities: never, providers: never) => Promise<R>): Promise<R> => ambient.enterFrame(key, async () => {
+      const journal: Undo[] = [];
+      const record = (storage: Storage, name: string, schema: SchemaView) =>
+        validator(recording(storage, name, schema, journal), name, schema);
+      try {
+        return await inScope(scope, members, world.storageFactory!, record, fn as never);
+      } catch (cause) {
+        return unwind(journal, cause, world.log);
+      }
+    }),
+  };
+}
+
+/** What a `Together<[…]>` key resolves to — the block, and nothing else. */
+interface Frame {
+  run<R>(fn: (entities: never, providers: never) => Promise<R>): Promise<R>;
+}

package/src/contract.ts

@@ -18,6 +18,7 @@ export type { Comparison } from './storage/Comparison.js';
 export { toPublicError } from './wire/http-error.js';
 export { Invocation } from './wire/Invocation.js';
 export type { InvocationContext } from './wire/InvocationContext.js';
+export type { PartialInvocation } from './wire/PartialInvocation.js';
 export { Call } from './wire/Call.js';
 export { RouteAddress } from './wire/RouteAddress.js';
 export type { FrondCall } from './wire/FrondCall.js';

package/src/descriptor/FrondDescriptor.ts

@@ -34,6 +34,13 @@ export interface FrondDescriptor {
    * domain. Set by the boot, never by a declaration.
    */
   brought?: true;
+  /**
+   * The frond this one inherits code from — its scope hangs off that one's, so a service, a
+   * repository, a port or a middleware declared there answers here too. The same word the
+   * config uses, set by the boot from `FougereConfig.fronds` and never by a scan: the disk is
+   * flat, and a directory says nothing about who shares its code.
+   */
+  extends?: string;
   /** The ops that finish a fact, in order — see `FrondConfig.pipes`. */
   pipes?: Record<string, string[]>;
   /**

package/src/descriptor/MiddlewareEntry.ts

@@ -1,14 +1,15 @@
 /**
- * A discovered middleware — a class declaring `around(ctx, next)`, which runs before and
- * after every operation in its scope.
+ * A discovered middleware — a class declaring `around(ctx, next)`, which runs before and after
+ * every operation of its frond, and of the fronds that inherit from it.
+ *
+ * How far it reaches is not written here: it is where the frond sits in `FougereConfig.fronds`,
+ * and stating it twice would put one decision in two places.
  */
 export interface MiddlewareEntry {
-  /** Class name — what `frond.config.ts` addresses to widen the scope. */
+  /** Class name — the key it registers under in its frond's scope. */
   name: string;
   /** The middleware class. */
   ctor: new (...args: never[]) => unknown;
-  /** How far it reaches: its own frond's entities, or every operation in the process. */
-  scope: 'frond' | 'app';
   /** Constructor dependency type names (from AST scan). */
   deps: string[];
   /** Absolute file path (for debugging). */

package/src/descriptor/ProviderEntry.ts

@@ -15,4 +15,11 @@ export interface ProviderEntry {
   deps: string[];
   /** Absolute file path (for debugging). */
   filePath: string;
+  /**
+   * It stated `implements AsyncDisposable` — so there is ONE of it per frond, and that frond's
+   * scope closes it. The language's own marker, which `App` already answers; a provider that
+   * says nothing is built per consumer and closed by nobody, which is right for one that holds
+   * nothing.
+   */
+  kept?: true;
 }

package/src/dispatch/Dependent.ts

@@ -0,0 +1,19 @@
+import type { OnDelete } from '@fougere/schema';
+
+/**
+ * A `ref()` read from the TARGET's side: rows that name it, and what becomes of them.
+ *
+ * The dual of `RelationCheck`, which reads the same declaration from the child's side to judge
+ * a write. Only what no foreign key holds reaches here — a key answers at the rows, inside the
+ * delete's own transaction, and nothing in this process would see it happen.
+ *
+ * Documented: [entities](https://fougere.dev/docs/schema/entities).
+ */
+export interface Dependent {
+  /** The entity whose rows name the target — `post`. */
+  entity: string;
+  /** The field carrying the key — `authorId`. */
+  field: string;
+  /** Unstated is `restrict`: what a foreign key does when nothing is said. */
+  onDelete: OnDelete;
+}

package/src/dispatch/Dispatcher.ts

@@ -7,6 +7,7 @@ import type { RoutePolicy } from './RoutePolicy.js';
 import { RouteRegistry } from './RouteRegistry.js';
 import { routeNotFound, servedOperations } from './routeNotFound.js';
 import type { InFlight } from './InFlight.js';
+import type { Journal } from './Journal.js';
 
 /** Resolves and executes every call through the same transverse lifecycle. */
 export class Dispatcher implements DispatchPort {
@@ -15,22 +16,57 @@ export class Dispatcher implements DispatchPort {
     private readonly inFlight: InFlight,
     private readonly lifecycle = new DispatchLifecycle(),
     private readonly policy?: RoutePolicy,
+    private readonly journalOf?: () => Journal | undefined,
   ) {}
 
+  /** The route that answers this address, or the refusal naming what is served instead. */
+  private async routeFor(call: Call): Promise<Route> {
+    const known = this.routes.find(call.address);
+    const resolved = known ?? await this.routes.resolve(call.address);
+    const route = resolved && (!this.policy || this.policy.accepts(resolved)) ? resolved : undefined;
+    if (!route) {
+      throw this.policy?.notFound?.(call, this.routes.routes())
+        ?? routeNotFound(call, servedOperations(call, this.routes.routes(), this.policy));
+    }
+
+    return route;
+  }
+
+  /**
+   * A kept call publishes no dispatch event and enters no flight: it has not been answered,
+   * and counting it here would report one call spanning the days until its hour.
+   *
+   * Its address is resolved all the same. What is kept is made hours later, by then against
+   * whatever the app still serves — so an address nothing answers is refused to the caller who
+   * can still fix it, rather than to a beat nobody is watching.
+   */
+  private async keep(call: Call, runAt: number): Promise<undefined> {
+    await this.routeFor(call);
+
+    const journal = this.journalOf?.();
+    if (!journal) {
+      throw new Error(
+        `${call.address.toString()} asks to run at ${new Date(runAt).toISOString()}, and nothing keeps it.`
+        + ' Install a package answering Journal — @fougere/workflow.',
+      );
+    }
+
+    await journal.keep(call, runAt);
+
+    return undefined;
+  }
+
   async dispatch(call: Call): Promise<unknown> {
+    const { runAt } = call.invocation;
+    if (runAt !== undefined) return this.keep(call, runAt);
+
     let route: Route | undefined;
     let release: (() => void) | undefined;
     this.lifecycle.publish(DispatchEvent.received(call));
 
     try {
       release = this.inFlight.enter(call.address.entity, call.address.operation);
-      const known = this.routes.find(call.address);
-      const resolved = known ?? await this.routes.resolve(call.address);
-      route = resolved && (!this.policy || this.policy.accepts(resolved)) ? resolved : undefined;
-      if (!route) {
-        throw this.policy?.notFound?.(call, this.routes.routes())
-          ?? routeNotFound(call, servedOperations(call, this.routes.routes(), this.policy));
-      }
+      route = await this.routeFor(call);
 
       this.lifecycle.publish(DispatchEvent.resolved(call, route.kind));
       const result = await route.execute(call);

package/src/dispatch/HandlerFacade.ts

@@ -40,6 +40,11 @@ export class HandlerFacade {
   /** A computed field's parameters and the collectors in scope are both boot-time facts. */
   private readonly presenterPlans: Map<string, BindingPlan>;
 
+  private collectorResolver = (typeName: string): CollectorResolver | undefined => {
+    try { return this.scope.resolve(collectorKeyOf(typeName)) as CollectorResolver; }
+    catch { return undefined; }
+  };
+
   constructor(
     private readonly handler: HandlerEntry,
     private readonly scope: Container,
@@ -93,20 +98,30 @@ export class HandlerFacade {
       invocation,
     };
 
-    return runMiddlewares(this.facade.middlewares(), context, async () => {
-      const validated = validateInput(contract.input, invocation, entity, op);
-      context.invocation = validated;
+    return runMiddlewares(this.facade.middlewares(), context, () => this.answer(op, contract, context, invocation));
+  }
 
-      const args = contract.binding
-        ? await this.arguments.resolve(contract.binding, validated)
-        : [];
-      const { instance, method } = this.resolveImplementation(op);
-      const view = this.viewOf(op);
-      const output = view.project(await instance[method](...args));
+  /**
+   * What the handler answers, once the middlewares let the call through: the input judged, the
+   * arguments bound, the row projected onto the view this audience sees.
+   */
+  private async answer(
+    op: string,
+    contract: OperationContract,
+    context: OperationContext,
+    invocation: Invocation,
+  ): Promise<unknown> {
+    const validated = validateInput(contract.input, invocation, this.handler.address, op);
+    context.invocation = validated;
 
-      const { presenter } = this.facade;
-      return view.closed || !presenter ? output : this.present(op, presenter, output, validated);
-    });
+    const args = contract.binding ? await this.arguments.resolve(contract.binding, validated) : [];
+    const { instance, method } = this.resolveImplementation(op);
+    const view = this.viewOf(op);
+    const output = view.project(await instance[method](...args));
+
+    const { presenter } = this.facade;
+
+    return view.closed || !presenter ? output : this.present(op, presenter, output, validated);
   }
 
   /** The computed fields a presenter adds, over the page the façade just projected. */
@@ -168,11 +183,6 @@ export class HandlerFacade {
     return resolved;
   }
 
-  private collectorResolver = (typeName: string): CollectorResolver | undefined => {
-    try { return this.scope.resolve(collectorKeyOf(typeName)) as CollectorResolver; }
-    catch { return undefined; }
-  };
-
   /** The handler itself, resolved on first call — never at boot. */
   private resolveHandler(): any {
     if (!this.instance) this.instance = this.scope.resolve(this.handlerKey);

package/src/dispatch/Journal.ts

@@ -0,0 +1,26 @@
+import type { Call } from '../wire/Call.js';
+
+/**
+ * What writes a release down while it happens, when a package provides one.
+ *
+ * Core does the same hops in the same order either way — children before their parent, so an
+ * interruption leaves fewer children and never an orphan. What a journal adds is that somebody
+ * can finish what a stopped process started: the row says a release began, and a sweep redoes
+ * it. Redoing is safe because every hop already is — a row taken out twice is taken out once.
+ *
+ * What writes a release down writes none of its own: the boot leaves out the entities of the
+ * fronds an extension BROUGHT, so keeping the row that says a release began does not begin one.
+ * Read from what was brought rather than written down, the way `CARRIES_LINE` is.
+ *
+ * Documented: [entities](https://fougere.dev/docs/schema/entities).
+ */
+export interface Journal {
+  /** Hold this call until `runAt`, so a sweep dispatches it then and nobody waits for it now. */
+  keep(call: Call, runAt: number): Promise<void>;
+  /** Take this release on, or say another process is already driving it. */
+  open(entity: string, key: string): Promise<'taken' | 'busy'>;
+  close(entity: string, key: string): Promise<void>;
+}
+
+/** The container key a package registers its journal under. */
+export const JOURNAL = 'Journal';