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

package/src/boot/declared.ts

@@ -5,6 +5,7 @@
  */
 import type { FrondDescriptor } from '../descriptor/FrondDescriptor.js';
 import { facadeKeyOf } from '../wire/Facade.js';
+import { factsAnnouncedBy, factsAwaitedBy, factsListenedTo } from '../wire/Emit.js';
 import { type DeclaredEdge } from '../wire/topology/DeclaredEdge.js';
 import { type DeclaredFrond } from '../wire/topology/DeclaredFrond.js';
 import { type DeclaredTopology } from '../wire/topology/DeclaredTopology.js';
@@ -23,6 +24,9 @@ export function declaredTopologyOf({ fronds, remotes }: Declaring): DeclaredTopo
 
 function placements(hosted: readonly FrondDescriptor[], remotes: Readonly<Record<string, string>>): DeclaredFrond[] {
   const here = hosted
+    // A frond its family inherits from answers at no address, so it has no placement to
+    // report: it stands in every process that holds one of its children.
+    .filter((frond) => frond.handlers.length > 0)
     .filter((frond) => !remotes[frond.name])
     .map((frond) => ({ frond: frond.name, placement: 'local' as const }));
 
@@ -65,21 +69,52 @@ export function reachedBy(deps: readonly string[], from: string, index: Map<stri
   return [...new Set(reached)];
 }
 
+/**
+ * The two ways a call leaves a frond: a façade its code names, and a fact it announces.
+ *
+ * The second cannot be read the way the first is. A dependency names what it reaches, where an
+ * announcement names a SUBJECT and a subscriber names nothing at all — so the edge is found from
+ * both ends, the announcer's deps and the listener's binding plan. Reading the deps alone
+ * reported `demos/pipe-split` as four fronds with nothing between them, and three of its four
+ * fronds are reached by a fact.
+ */
 function crossings(hosted: readonly FrondDescriptor[]): DeclaredEdge[] {
   const index = servedBy(hosted);
+  const heard = listenedBy(hosted);
   const found = new Map<string, DeclaredEdge>();
+  const cross = (from: string, to: string) => {
+    if (from !== to) found.set(`${from} ${to}`, { from, to });
+  };
 
   for (const frond of hosted) {
     for (const handler of frond.handlers) {
-      for (const to of reachedBy(handler.deps, frond.name, index)) {
-        found.set(`${frond.name} ${to}`, { from: frond.name, to });
-      }
+      for (const to of reachedBy(handler.deps, frond.name, index)) cross(frond.name, to);
+    }
+    for (const fact of announcedIn(frond)) {
+      for (const to of heard.get(fact) ?? []) cross(frond.name, to);
     }
   }
 
   return [...found.values()];
 }
 
+/** Which fronds listen to each fact — every one of them, since an announcement names no recipient. */
+function listenedBy(hosted: readonly FrondDescriptor[]): Map<string, string[]> {
+  const index = new Map<string, string[]>();
+  for (const frond of hosted) {
+    for (const fact of factsListenedTo(frond.handlers)) {
+      index.set(fact, [...(index.get(fact) ?? []), frond.name]);
+    }
+  }
+
+  return index;
+}
+
+/** A fact announced here, whether the announcer waits for an answer or not. */
+function announcedIn(frond: FrondDescriptor): string[] {
+  return [...new Set([...factsAnnouncedBy(frond.handlers), ...factsAwaitedBy(frond.handlers)])];
+}
+
 function hostOf(address: string): string {
   try {
     const url = new URL(address);

package/src/boot/frame.ts

@@ -45,6 +45,15 @@ function refuseAmbiguousUpsert(entity: string, gesture: string): never {
  * The storage a member is handed inside a compensated frame: the same port, writing the same rows,
  * leaving an inverse behind each time.
  */
+/** What one member's writes are recorded against, inside one frame. */
+interface Recording {
+  base: Undoable;
+  recorded: Undoable;
+  entity: string;
+  key: string;
+  journal: Undo[];
+}
+
 export function recording<T extends object>(storage: T, entity: string, schema: SchemaView, journal: Undo[]): T {
   const base = storage as unknown as Undoable;
   if (typeof base.create !== 'function' || typeof base.update !== 'function') return storage;
@@ -58,22 +67,37 @@ export function recording<T extends object>(storage: T, entity: string, schema:
   }
 
   const recorded = Object.create(storage) as T & Undoable;
+  const into: Recording = { base, recorded, entity, key, journal };
+
+  recordCreate(into);
+  recordUpdate(into);
+  recordDelete(into);
+  recordUpserts(into, schema);
+
+  return recorded;
+}
 
+/** The inverse of an insertion is a deletion by the key the write handed back. */
+function recordCreate({ base, recorded, entity, key, journal }: Recording): void {
   recorded.create = async function (...args) {
     const row = await base.create.apply(this, args);
     const id = String(row[key]);
     journal.push({ what: `create ${entity}#${id}`, run: () => base.delete.call(this, id).then(() => undefined) });
     return row;
   };
+}
 
+/**
+ * Compared against what the WRITE produced, not against the patch: an `update: 'now'` field is
+ * stamped by the storage, so the patch is not what the row now holds.
+ */
+function recordUpdate({ base, recorded, entity, journal }: Recording): void {
   recorded.update = async function (...args) {
     const [id, patch] = args;
     const before = await base.findById.call(this, id);
     const row = await base.update.apply(this, args);
     if (!before) return row;
 
-    // Compare against what the WRITE produced, not against the patch: a `update: 'now'`
-    // field is stamped by the storage, so the patch is not what the row now holds.
     const touched = Object.keys(patch);
     const wrote = pick(row, touched);
     journal.push({
@@ -97,7 +121,10 @@ export function recording<T extends object>(storage: T, entity: string, schema:
     });
     return row;
   };
+}
 
+/** Nothing to take back when the row was already gone. */
+function recordDelete({ base, recorded, entity, journal }: Recording): void {
   recorded.delete = async function (id) {
     const before = await base.findById.call(this, id);
     const removed = await base.delete.call(this, id);
@@ -106,10 +133,14 @@ export function recording<T extends object>(storage: T, entity: string, schema:
     }
     return removed;
   };
+}
 
-  // An upsert says neither what it wrote over nor what it inserted, so the frame reads the
-  // keys first: what was there is restored, what was not is deleted. One extra query for
-  // the page, which is the same bargain `update` already makes for one row.
+/**
+ * An upsert says neither what it wrote over nor what it inserted, so the frame reads the keys
+ * first: what was there is restored, what was not is deleted. One extra query for the page,
+ * the same bargain `update` already makes for one row.
+ */
+function recordUpserts({ base, recorded, entity, key, journal }: Recording, schema: SchemaView): void {
   const undoUpsert = async function (this: unknown, rows: readonly Record<string, unknown>[]): Promise<Undo> {
     const ids = rows.map((row) => String(row[key]));
     const before = await base.findByKeys.call(this, ids);
@@ -125,27 +156,27 @@ export function recording<T extends object>(storage: T, entity: string, schema:
     };
   };
 
-  if (typeof base.upsert === 'function') {
+  const upsert = base.upsert;
+  if (typeof upsert === 'function') {
     recorded.upsert = async function (input, ...rest) {
       if (declares(schema, 'unique')) refuseAmbiguousUpsert(entity, 'upsert');
       const undo = await undoUpsert.call(this, [input]);
-      const row = await base.upsert!.call(this, input, ...rest);
+      const row = await upsert.call(this, input, ...rest);
       journal.push(undo);
       return row;
     };
   }
 
-  if (typeof base.upsertAll === 'function') {
+  const upsertAll = base.upsertAll;
+  if (typeof upsertAll === 'function') {
     recorded.upsertAll = async function (inputs, ...rest) {
       if (declares(schema, 'unique')) refuseAmbiguousUpsert(entity, 'upsertAll');
       const undo = await undoUpsert.call(this, inputs);
-      const written = await base.upsertAll!.call(this, inputs, ...rest);
+      const written = await upsertAll.call(this, inputs, ...rest);
       journal.push(undo);
       return written;
     };
   }
-
-  return recorded;
 }
 
 /** Replay the inverses, most recent first, and report rather than pretend. */

package/src/boot/hosted.ts

@@ -44,11 +44,12 @@ export async function hostedBy(sources: HostedSources): Promise<ScanResult> {
     ? await (typeof sources.scan === 'function' ? sources.scan() : sources.scan)
     : undefined;
 
-  if (!sources.fronds) return scanned ?? { fronds: Fronds.hosting([]), diagnostics: [] };
+  const stated = sources.fronds;
+  if (!stated) return scanned ?? { fronds: Fronds.hosting([]), diagnostics: [] };
 
   const found = scanned?.fronds ?? [];
-  const configured = sources.fronds.map((f) => completed(f, found.find((s) => s.name === f.name)));
-  const discovered = found.filter((f) => !sources.fronds!.some((s) => s.name === f.name));
+  const configured = stated.map((f) => completed(f, found.find((s) => s.name === f.name)));
+  const discovered = found.filter((f) => !stated.some((s) => s.name === f.name));
 
   return { fronds: Fronds.hosting([...configured, ...discovered]), diagnostics: scanned?.diagnostics ?? [] };
 }