@fougere/core 0.8.4-alpha.0 → 0.9.0-alpha.1

package/dist/wire/binding.js

@@ -17,14 +17,19 @@ export function computeBindingPlan(params, collectorTypeNames) {
         // scan spells it, and the two agree on one word only — `AuthorUser` looked up as
         // `authoruser` missed `authorUser` and fell through to branch 4, the request input.
         const typeKey = lowerFirst(typeName);
-        // 0. Fact — `Fact<X>` names itself, so nothing has to be known in advance. It comes
-        //    FIRST because branch 4 would otherwise hand it the caller's input under the name
-        //    of something that happened.
-        const factOf = param.type.name === 'Fact' ? param.type.generics?.[0]?.name : undefined;
-        if (factOf) {
+        // 0. Fact, or the same fact before it is final. Both name themselves, so nothing has
+        //    to be known in advance, and they come FIRST because branch 4 would otherwise hand
+        //    either the caller's input under the name of something that happened.
+        const announced = param.type.name === 'Fact' || param.type.name === 'Pipe'
+            ? param.type.generics?.[0]?.name
+            : undefined;
+        if (announced) {
             return {
                 name: param.name,
-                source: { kind: 'fact', factName: lowerFirst(factOf) },
+                source: {
+                    kind: (param.type.name === 'Pipe' ? 'pipe' : 'fact'),
+                    factName: lowerFirst(announced),
+                },
                 optional: param.optional ?? false,
             };
         }

package/dist/wire/binding.js.map

@@ -1 +1 @@
-{"version":3,"file":"binding.js","sourceRoot":"","sources":["../../src/wire/binding.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAsB7C,iDAAiD;AAEjD,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC;AAE5D,SAAS,WAAW,CAAC,QAAgB;IACnC,IAAI,QAAQ,KAAK,QAAQ;QAAE,OAAO,QAAQ,CAAC;IAC3C,IAAI,QAAQ,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC7C,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,iDAAiD;AAEjD,qDAAqD;AACrD,MAAM,UAAU,kBAAkB,CAChC,MAAe,EACf,kBAA+B;IAE/B,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QAC1B,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC;QACjC,8EAA8E;QAC9E,iFAAiF;QACjF,oFAAoF;QACpF,MAAM,OAAO,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC;QAErC,oFAAoF;QACpF,sFAAsF;QACtF,iCAAiC;QACjC,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;QACvF,IAAI,MAAM,EAAE,CAAC;YACX,OAAO;gBACL,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,MAAM,EAAE,EAAE,IAAI,EAAE,MAAe,EAAE,QAAQ,EAAE,UAAU,CAAC,MAAM,CAAC,EAAE;gBAC/D,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,KAAK;aAClC,CAAC;QACJ,CAAC;QAED,sEAAsE;QACtE,IAAI,kBAAkB,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;YACpC,OAAO;gBACL,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,MAAM,EAAE,EAAE,IAAI,EAAE,WAAoB,EAAE,QAAQ,EAAE,OAAO,EAAE;gBACzD,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,KAAK;aAClC,CAAC;QACJ,CAAC;QAED,iDAAiD;QACjD,IAAI,QAAQ,KAAK,mBAAmB,EAAE,CAAC;YACrC,OAAO;gBACL,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,MAAM,EAAE,EAAE,IAAI,EAAE,SAAkB,EAAE;gBACpC,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,KAAK;aAClC,CAAC;QACJ,CAAC;QAED,sDAAsD;QACtD,IAAI,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC7B,OAAO;gBACL,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,MAAM,EAAE;oBACN,IAAI,EAAE,OAAgB;oBACtB,IAAI,EAAE,KAAK,CAAC,IAAI;oBAChB,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC;iBAC9B;gBACD,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,KAAK;aAClC,CAAC;QACJ,CAAC;QAED,6BAA6B;QAC7B,OAAO;YACL,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,MAAM,EAAE,EAAE,IAAI,EAAE,OAAgB,EAAE;YAClC,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,KAAK;SAClC,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"binding.js","sourceRoot":"","sources":["../../src/wire/binding.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AA4B7C,iDAAiD;AAEjD,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC;AAE5D,SAAS,WAAW,CAAC,QAAgB;IACnC,IAAI,QAAQ,KAAK,QAAQ;QAAE,OAAO,QAAQ,CAAC;IAC3C,IAAI,QAAQ,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC7C,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,iDAAiD;AAEjD,qDAAqD;AACrD,MAAM,UAAU,kBAAkB,CAChC,MAAe,EACf,kBAA+B;IAE/B,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QAC1B,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC;QACjC,8EAA8E;QAC9E,iFAAiF;QACjF,oFAAoF;QACpF,MAAM,OAAO,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC;QAErC,qFAAqF;QACrF,uFAAuF;QACvF,0EAA0E;QAC1E,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,KAAK,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,KAAK,MAAM;YACxE,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI;YAChC,CAAC,CAAC,SAAS,CAAC;QACd,IAAI,SAAS,EAAE,CAAC;YACd,OAAO;gBACL,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,MAAM,EAAE;oBACN,IAAI,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAoB;oBACvE,QAAQ,EAAE,UAAU,CAAC,SAAS,CAAC;iBAChC;gBACD,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,KAAK;aAClC,CAAC;QACJ,CAAC;QAED,sEAAsE;QACtE,IAAI,kBAAkB,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;YACpC,OAAO;gBACL,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,MAAM,EAAE,EAAE,IAAI,EAAE,WAAoB,EAAE,QAAQ,EAAE,OAAO,EAAE;gBACzD,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,KAAK;aAClC,CAAC;QACJ,CAAC;QAED,iDAAiD;QACjD,IAAI,QAAQ,KAAK,mBAAmB,EAAE,CAAC;YACrC,OAAO;gBACL,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,MAAM,EAAE,EAAE,IAAI,EAAE,SAAkB,EAAE;gBACpC,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,KAAK;aAClC,CAAC;QACJ,CAAC;QAED,sDAAsD;QACtD,IAAI,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC7B,OAAO;gBACL,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,MAAM,EAAE;oBACN,IAAI,EAAE,OAAgB;oBACtB,IAAI,EAAE,KAAK,CAAC,IAAI;oBAChB,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC;iBAC9B;gBACD,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,KAAK;aAClC,CAAC;QACJ,CAAC;QAED,6BAA6B;QAC7B,OAAO;YACL,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,MAAM,EAAE,EAAE,IAAI,EAAE,OAAgB,EAAE;YAClC,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,KAAK;SAClC,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/wire/emit.d.ts

@@ -1,13 +1,45 @@
-/** What an emitter injects. */
-export type Emit<T> = (fact: T) => Promise<void>;
-/** What a subscriber accepts — and what it PROMISES about itself. */
+/**
+ * What an emitter injects. PARTIAL, because announcing is what REALIZES the fact's
+ * `lifecycle.create` — an `at: created()` is stamped by `Emissions`, so requiring it from
+ * the announcer made every emitter cast its way past its own type. A missing field is
+ * still refused, by the judge that reads the fact at announce time.
+ */
+export type Emit<T, A = never> = (fact: Partial<T>) => Promise<A[]>;
+/**
+ * What a subscriber accepts — and what it PROMISES about itself.
+ *
+ * What it ANSWERS is its own to choose: `Promise<void>` says nothing, any other type is an
+ * opinion. It reaches an announcer that asked for one — `Emit<CanBook, Verdict>` — and
+ * nobody otherwise, since a plain announcement does not wait.
+ */
 export type Fact<T> = T;
+/**
+ * The same fact, BEFORE it is final: an op taking one ANSWERS the value every subscriber
+ * then receives, so it is the declared form of what `Emissions.stamped` already does for
+ * `created()`.
+ *
+ * Not a second announcement and not a chain a subscriber joins: the links run once, before
+ * anyone is handed anything, which is what keeps a fact the same for every reader.
+ */
+export type Pipe<T> = T;
 /** The container key of an emission — THE one place that spells the format. */
 export declare function emitKeyOf(fact: string): string;
+/**
+ * The key of an emission that WAITS — `Emit<CanBook, Verdict>`, where the second type is
+ * the whole difference. A separate key because they are two functions: one hands the fact
+ * over and returns, the other waits for every subscriber and gives back what they said.
+ */
+export declare function awaitKeyOf(fact: string): string;
 /** The fact behind an emission key, or `undefined` when the key is not one. */
 export declare function factOfEmitKey(key: string): string | undefined;
+/** The fact behind an awaited emission's key — the dual, read the same way. */
+export declare function factOfAwaitKey(key: string): string | undefined;
 /** What a set of handlers ANNOUNCES — `Emit<T>` read back out of their dependencies. */
 export declare function factsAnnouncedBy(handlers: readonly {
     deps: readonly string[];
 }[]): string[];
+/** What a set of handlers announces AND WAITS FOR — the same reading, one suffix apart. */
+export declare function factsAwaitedBy(handlers: readonly {
+    deps: readonly string[];
+}[]): string[];
 //# sourceMappingURL=emit.d.ts.map

package/dist/wire/emit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../src/wire/emit.ts"],"names":[],"mappings":"AAGA,+BAA+B;AAC/B,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAEjD,qEAAqE;AACrE,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC;AAExB,+EAA+E;AAC/E,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9C;AAID,+EAA+E;AAC/E,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAI7D;AAED,wFAAwF;AACxF,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,SAAS;IAAE,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,EAAE,GAAG,MAAM,EAAE,CAO3F"}
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../src/wire/emit.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;AAEpE;;;;;;GAMG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC;AAExB;;;;;;;GAOG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC;AAExB,+EAA+E;AAC/E,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE/C;AAKD,+EAA+E;AAC/E,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE7D;AAED,+EAA+E;AAC/E,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE9D;AAQD,wFAAwF;AACxF,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,SAAS;IAAE,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,EAAE,GAAG,MAAM,EAAE,CAE3F;AAED,2FAA2F;AAC3F,wBAAgB,cAAc,CAAC,QAAQ,EAAE,SAAS;IAAE,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,EAAE,GAAG,MAAM,EAAE,CAEzF"}

package/dist/wire/emit.js

@@ -4,18 +4,41 @@ import { lowerFirst } from '@fougere/schema';
 export function emitKeyOf(fact) {
     return `${lowerFirst(fact)}Emit`;
 }
+/**
+ * The key of an emission that WAITS — `Emit<CanBook, Verdict>`, where the second type is
+ * the whole difference. A separate key because they are two functions: one hands the fact
+ * over and returns, the other waits for every subscriber and gives back what they said.
+ */
+export function awaitKeyOf(fact) {
+    return `${lowerFirst(fact)}Await`;
+}
 const SUFFIX = 'Emit';
+const AWAIT_SUFFIX = 'Await';
 /** The fact behind an emission key, or `undefined` when the key is not one. */
 export function factOfEmitKey(key) {
-    return key.length > SUFFIX.length && key.endsWith(SUFFIX)
-        ? key.slice(0, -SUFFIX.length)
+    return behind(key, SUFFIX);
+}
+/** The fact behind an awaited emission's key — the dual, read the same way. */
+export function factOfAwaitKey(key) {
+    return behind(key, AWAIT_SUFFIX);
+}
+function behind(key, suffix) {
+    return key.length > suffix.length && key.endsWith(suffix)
+        ? key.slice(0, -suffix.length)
         : undefined;
 }
 /** What a set of handlers ANNOUNCES — `Emit<T>` read back out of their dependencies. */
 export function factsAnnouncedBy(handlers) {
+    return factsIn(handlers, factOfEmitKey);
+}
+/** What a set of handlers announces AND WAITS FOR — the same reading, one suffix apart. */
+export function factsAwaitedBy(handlers) {
+    return factsIn(handlers, factOfAwaitKey);
+}
+function factsIn(handlers, behindKey) {
     return [...new Set(handlers
             .flatMap((handler) => handler.deps)
-            .map(factOfEmitKey)
+            .map(behindKey)
             .filter((fact) => fact !== undefined))];
 }
 //# sourceMappingURL=emit.js.map

package/dist/wire/emit.js.map

@@ -1 +1 @@
-{"version":3,"file":"emit.js","sourceRoot":"","sources":["../../src/wire/emit.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAQ7C,+EAA+E;AAC/E,MAAM,UAAU,SAAS,CAAC,IAAY;IACpC,OAAO,GAAG,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC;AACnC,CAAC;AAED,MAAM,MAAM,GAAG,MAAM,CAAC;AAEtB,+EAA+E;AAC/E,MAAM,UAAU,aAAa,CAAC,GAAW;IACvC,OAAO,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC;QACvD,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC;QAC9B,CAAC,CAAC,SAAS,CAAC;AAChB,CAAC;AAED,wFAAwF;AACxF,MAAM,UAAU,gBAAgB,CAAC,QAAgD;IAC/E,OAAO,CAAC,GAAG,IAAI,GAAG,CAChB,QAAQ;aACL,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;aAClC,GAAG,CAAC,aAAa,CAAC;aAClB,MAAM,CAAC,CAAC,IAAI,EAAkB,EAAE,CAAC,IAAI,KAAK,SAAS,CAAC,CACxD,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"emit.js","sourceRoot":"","sources":["../../src/wire/emit.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AA6B7C,+EAA+E;AAC/E,MAAM,UAAU,SAAS,CAAC,IAAY;IACpC,OAAO,GAAG,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC;AACnC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAC,IAAY;IACrC,OAAO,GAAG,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC;AACpC,CAAC;AAED,MAAM,MAAM,GAAG,MAAM,CAAC;AACtB,MAAM,YAAY,GAAG,OAAO,CAAC;AAE7B,+EAA+E;AAC/E,MAAM,UAAU,aAAa,CAAC,GAAW;IACvC,OAAO,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;AAC7B,CAAC;AAED,+EAA+E;AAC/E,MAAM,UAAU,cAAc,CAAC,GAAW;IACxC,OAAO,MAAM,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;AACnC,CAAC;AAED,SAAS,MAAM,CAAC,GAAW,EAAE,MAAc;IACzC,OAAO,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC;QACvD,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC;QAC9B,CAAC,CAAC,SAAS,CAAC;AAChB,CAAC;AAED,wFAAwF;AACxF,MAAM,UAAU,gBAAgB,CAAC,QAAgD;IAC/E,OAAO,OAAO,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;AAC1C,CAAC;AAED,2FAA2F;AAC3F,MAAM,UAAU,cAAc,CAAC,QAAgD;IAC7E,OAAO,OAAO,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC;AAC3C,CAAC;AAED,SAAS,OAAO,CACd,QAAgD,EAChD,SAA8C;IAE9C,OAAO,CAAC,GAAG,IAAI,GAAG,CAChB,QAAQ;aACL,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;aAClC,GAAG,CAAC,SAAS,CAAC;aACd,MAAM,CAAC,CAAC,IAAI,EAAkB,EAAE,CAAC,IAAI,KAAK,SAAS,CAAC,CACxD,CAAC,CAAC;AACL,CAAC"}

package/dist/wire/loggerMiddleware.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loggerMiddleware.d.ts","sourceRoot":"","sources":["../../src/wire/loggerMiddleware.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,8EAA8E;AAC9E,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,CAe9D"}
+{"version":3,"file":"loggerMiddleware.d.ts","sourceRoot":"","sources":["../../src/wire/loggerMiddleware.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAGnD,8EAA8E;AAC9E,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,CAoB9D"}

package/dist/wire/loggerMiddleware.js

@@ -1,6 +1,12 @@
+import { CARRIES_LINE } from '../builtin/LogLine.js';
 /** Create a logger middleware that logs operation entry, exit, and errors. */
 export function loggerMiddleware(logger) {
     return async (ctx, next) => {
+        // An op that CARRIES a line writes none: it is dispatched, so logging it announces a
+        // line inside the announcement of one — `Emission cycle: logLine → logLine`, which is
+        // the emission catching what `onLog`'s try/catch used to swallow.
+        if (CARRIES_LINE.has(ctx.entity))
+            return next();
         const start = performance.now();
         logger.info(`${ctx.entity}.${ctx.operation}`);
         try {

package/dist/wire/loggerMiddleware.js.map

@@ -1 +1 @@
-{"version":3,"file":"loggerMiddleware.js","sourceRoot":"","sources":["../../src/wire/loggerMiddleware.ts"],"names":[],"mappings":"AAMA,8EAA8E;AAC9E,MAAM,UAAU,gBAAgB,CAAC,MAAc;IAC7C,OAAO,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE;QACzB,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;QAChC,MAAM,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC;QAC9C,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;YAC5B,MAAM,EAAE,GAAG,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;YAClD,MAAM,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,SAAS,KAAK,EAAE,KAAK,CAAC,CAAC;YACxD,OAAO,MAAM,CAAC;QAChB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,MAAM,EAAE,GAAG,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;YAClD,MAAM,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,SAAS,KAAK,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC;YAC9D,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC,CAAC;AACJ,CAAC"}
+{"version":3,"file":"loggerMiddleware.js","sourceRoot":"","sources":["../../src/wire/loggerMiddleware.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,8EAA8E;AAC9E,MAAM,UAAU,gBAAgB,CAAC,MAAc;IAC7C,OAAO,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE;QACzB,qFAAqF;QACrF,sFAAsF;QACtF,kEAAkE;QAClE,IAAI,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC;YAAE,OAAO,IAAI,EAAE,CAAC;QAEhD,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;QAChC,MAAM,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC;QAC9C,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;YAC5B,MAAM,EAAE,GAAG,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;YAClD,MAAM,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,SAAS,KAAK,EAAE,KAAK,CAAC,CAAC;YACxD,OAAO,MAAM,CAAC;QAChB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,MAAM,EAAE,GAAG,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;YAClD,MAAM,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,SAAS,KAAK,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC;YAC9D,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fougere/core",
-  "version": "0.8.4-alpha.0",
+  "version": "0.9.0-alpha.1",
   "description": "The core — scan, call contract, façades, remote stand-ins.",
   "keywords": [
     "fougere",
@@ -61,12 +61,12 @@
   "dependencies": {
     "@typescript/typescript6": "^6.0.2",
     "dequal": "^2.0.3",
-    "@fougere/container": "0.8.4-alpha.0",
-    "@fougere/schema": "0.8.4-alpha.0"
+    "@fougere/container": "0.9.0-alpha.1",
+    "@fougere/schema": "0.9.0-alpha.1"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
-    "@fougere/compiler": "0.8.4-alpha.0"
+    "@fougere/compiler": "0.9.0-alpha.1"
   },
   "publishConfig": {
     "access": "public"

package/src/boot/AppLifecycle.ts

@@ -1,8 +1,16 @@
 import type { App } from './types.js';
+import type { FrondDescriptor } from '../descriptor/frond.js';
 
 /** One process-level extension and its reversible lifecycle. */
 export interface Extension {
   name: string;
+  /**
+   * Fronds it brings — read BEFORE the ascent, since a frond is installed while the app is
+   * still being made and `up` receives one that already exists. This is how an optional
+   * package accepts a fact: `calls` and `observability` both want every `LogLine`, and a
+   * signature is the only way to ask for one.
+   */
+  fronds?: readonly FrondDescriptor[];
   up?(app: App): void | Promise<void>;
   down?(app: App): void | Promise<void>;
 }

package/src/boot/Emissions.ts

@@ -1,9 +1,9 @@
-import { applyCreate, dotted, type SchemaView } from '@fougere/schema';
+import { applyCreate, dotted, lowerFirst, type SchemaView } from '@fougere/schema';
 import type { Container } from '@fougere/container';
 import { validationErrorsOf } from '../wire/errors.js';
-import { emitKeyOf, factsAnnouncedBy } from '../wire/emit.js';
+import { awaitKeyOf, emitKeyOf, factsAnnouncedBy, factsAwaitedBy } from '../wire/emit.js';
 import { ambient } from '#ambient';
-import { EMPTY_INVOCATION } from '../wire/Invocation.js';
+import { Invocation } from '../wire/Invocation.js';
 import type { Logger } from '../builtin/logger.js';
 import type { Fronds } from '../descriptor/Fronds.js';
 import type { OperationsMap } from '../wire/operation.js';
@@ -22,6 +22,12 @@ export class Emissions {
   /** Who listens to what. Filled as each door's contracts are resolved. */
   private readonly subscribers = new Map<string, Listener[]>();
 
+  /** Who FINISHES a fact, in the order they run — see `orderPipes`. */
+  private readonly pipes = new Map<string, Listener[]>();
+
+  /** The order its OWNER declared, by fact — `pipes:` in `frond.config.ts`. */
+  private readonly ordered: Map<string, string[]>;
+
   /**
    * What is announced here, read from the DEPS and not from the subscribers: a handler declaring
    * `Emit<PostPublished>` must resolve it whether or not anybody listens, and announcing to nobody
@@ -29,6 +35,9 @@ export class Emissions {
    */
   private readonly announced: Set<string>;
 
+  /** What is announced AND waited for — `Emit<T, A>`, where the second type says so. */
+  private readonly awaited: Set<string>;
+
   constructor(
     fronds: Fronds,
     private readonly shapes: Map<string, SchemaView>,
@@ -37,6 +46,23 @@ export class Emissions {
     private readonly carry?: Carrier,
   ) {
     this.announced = new Set(fronds.flatMap((frond) => factsAnnouncedBy(frond.handlers)));
+    this.awaited = new Set(fronds.flatMap((frond) => factsAwaitedBy(frond.handlers)));
+    // Read from the frond that OWNS the fact: ordering is a decision about the fact, and
+    // a decision has one owner. A frond ordering a neighbour's fact is refused below.
+    this.ordered = new Map(fronds.flatMap((frond) => {
+      const owned = new Set(frond.entities.map((entity) => entity.name));
+
+      return Object.entries(frond.pipes ?? {}).map(([fact, order]) => {
+        if (!owned.has(lowerFirst(fact))) {
+          throw new Error(
+            `Frond '${frond.name}' orders the links of '${fact}', which it does not own.\n`
+            + '  The order belongs to the frond that declares the entity — state `pipes:` there.',
+          );
+        }
+
+        return [lowerFirst(fact), order] as const;
+      });
+    }));
   }
 
   /**
@@ -46,6 +72,10 @@ export class Emissions {
   note(contracts: OperationsMap, door: string): void {
     for (const [op, contract] of contracts) {
       for (const bound of contract.binding ?? []) {
+        if (bound.source.kind === 'pipe') {
+          this.claimPipe(bound.source.factName, { door, op });
+          continue;
+        }
         if (bound.source.kind !== 'fact') continue;
         const listeners = this.subscribers.get(bound.source.factName) ?? [];
         listeners.push({ door, op });
@@ -54,6 +84,51 @@ export class Emissions {
     }
   }
 
+  /** One more op that finishes this fact. What ORDER they run in is settled at `register`. */
+  private claimPipe(fact: string, taking: Listener): void {
+    const held = this.pipes.get(fact) ?? [];
+    if (held.some((one) => `${one.door}.${one.op}` === `${taking.door}.${taking.op}`)) return;
+    held.push(taking);
+    this.pipes.set(fact, held);
+  }
+
+  /**
+   * Put the links in the order their fact's owner declared, and refuse what it did not.
+   *
+   * Two links with no order refuse: nothing would say which finished the fact, and scan
+   * order is not an answer — the same reason two implementations of a port refuse. One
+   * link needs no declaration, because there is nothing to order.
+   */
+  private orderPipes(): void {
+    for (const [fact, links] of this.pipes) {
+      const declared = this.ordered.get(fact);
+      const named = (one: Listener) => `${one.door}.${one.op}`;
+
+      if (!declared) {
+        if (links.length < 2) continue;
+        throw new Error(
+          `${links.length} ops finish the fact '${fact}': ${links.map(named).join(', ')}.\n`
+          + '  They run one after another and nothing says in which order. State it on the '
+          + `frond that owns '${fact}':\n`
+          + `    export default { pipes: { ${fact}: ['FirstHandler', 'SecondHandler'] } };\n`
+          + '  Or make all but one accept `Fact<…>`, which changes nothing and reads it.',
+        );
+      }
+
+      const at = (one: Listener) => declared.findIndex((name) => doorOf(name) === one.door);
+      const unlisted = links.filter((one) => at(one) < 0);
+      if (unlisted.length > 0) {
+        throw new Error(
+          `${unlisted.map(named).join(', ')} finish${unlisted.length > 1 ? '' : 'es'} the fact `
+          + `'${fact}', and '${fact}' orders ${declared.join(', ')} — so where it runs is not said.\n`
+          + '  Add it to `pipes:`, or make it accept `Fact<…>`.',
+        );
+      }
+
+      this.pipes.set(fact, [...links].sort((one, other) => at(one) - at(other)));
+    }
+  }
+
   /** The shape a fact is validated by, when the fact is a declared entity. */
   shapeOf(fact: string): SchemaView | undefined {
     return this.shapes.get(fact);
@@ -64,18 +139,39 @@ export class Emissions {
     return [...this.subscribers.keys()];
   }
 
+  /** The doors that accept one fact — the addresses a middleware must leave alone. */
+  doorsFor(fact: string): string[] {
+    return (this.subscribers.get(fact) ?? []).map(({ door }) => door);
+  }
+
   /** Register one emission value per fact — announced here, or merely listened to. */
   register(): void {
+    this.orderPipes();
     for (const fact of new Set([...this.announced, ...this.subscribers.keys()])) {
       this.container.registerValue(emitKeyOf(fact), (raw: unknown) => this.announce(fact, raw));
     }
+    for (const fact of this.awaited) {
+      // Waiting means knowing WHO, and a carrier publishes to whoever subscribed elsewhere
+      // without bringing anything back — so the answers would hold this process's
+      // subscribers only, and say nothing about it. Refused here rather than half-answered
+      // at the first call: the second type is in a signature, so a boot can read it.
+      if (this.carry) {
+        throw new Error(
+          `'${fact}' is announced with an answer type, and this app has a carrier (\`onEmit\`).\n`
+          + '  Waiting means knowing who answers; a carrier reaches whoever subscribed '
+          + 'elsewhere and brings nothing back.\n'
+          + `  Name the subscribers in \`remotes:\`, or drop the second type of \`Emit<${fact}, …>\`.`,
+        );
+      }
+      this.container.registerValue(awaitKeyOf(fact), (raw: unknown) => this.announce(fact, raw, true));
+    }
     if (ambient.degraded && this.subscribers.size > 0) {
       this.log.warn('no async context on this runtime — an emission ring is not detected');
     }
   }
 
   /** Announcing. */
-  private async announce(fact: string, raw: unknown): Promise<void> {
+  private async announce(fact: string, raw: unknown, waiting = false): Promise<unknown[]> {
     /**
      * A fact announced inside a frame that then rolls back is a lie, and nothing can take it back:
      * announcing is DISPATCH — every subscriber has been handed the fact and the carrier has
@@ -83,15 +179,45 @@ export class Emissions {
      */
     await ambient.beforeAnnounce(fact);
 
-    const payload = this.stamped(fact, raw);
+    const payload = await this.finished(fact, this.stamped(fact, raw));
 
     /** Whoever is not in this process — and it is the ONLY way to reach them. */
     const delivery = this.carry?.(fact, payload);
     if (delivery) void Promise.resolve(delivery).catch((cause) => this.log.error(`${fact} — carrier refused it`, cause));
 
-    for (const { door, op, done } of this.handToListeners(fact, payload)) {
-      void done.catch((cause) => this.log.error(`${fact} → ${door}.${op}`, this.describeRefusal(fact, cause) ?? cause));
+    const handed = this.handToListeners(fact, payload);
+    if (!waiting) {
+      for (const { door, op, done } of handed) {
+        void done.catch((cause) => this.log.error(`${fact} → ${door}.${op}`, this.describeRefusal(fact, cause) ?? cause));
+      }
+
+      return [];
+    }
+
+    const settled = await Promise.allSettled(handed.map((one) => one.done));
+
+    // A subscriber that did not answer REFUSES the announcement, it does not shrink it: an
+    // announcer handed the survivors cannot tell three answers from two, and its own law
+    // then reads silence as consent — the room one would have refused gets booked.
+    const missing = settled.flatMap((result, at) =>
+      (result.status === 'rejected' ? [{ ...handed[at]!, reason: result.reason as unknown }] : []));
+    if (missing.length > 0) {
+      for (const { door, op, reason } of missing) {
+        this.log.error(`${fact} → ${door}.${op}`, this.describeRefusal(fact, reason) ?? reason);
+      }
+      throw new AggregateError(
+        missing.map((one) => one.reason),
+        `${fact} — ${missing.length} of ${handed.length} subscriber(s) did not answer`
+        + ` (${missing.map((one) => `${one.door}.${one.op}`).join(', ')}).`
+        + ' An announcement with an answer type waits for everyone: a partial answer would'
+        + ' look like a complete one.',
+      );
     }
+
+    // What answers NOTHING contributes nothing — a subscriber is free to have no opinion,
+    // and `Promise<void>` is how it says so.
+    return settled.flatMap((result) =>
+      (result.status === 'fulfilled' && result.value != null ? [result.value] : []));
   }
 
   /** Receiving. */
@@ -114,6 +240,38 @@ export class Emissions {
     }
   }
 
+  /**
+   * What the declared link answers, or the value as it stands when nothing declared one.
+   *
+   * Before anyone is handed anything, and once: every subscriber reads the same fact, which
+   * is the whole reason a fact can be said to be what happened. A link that refuses stops
+   * the announcement — it was finishing the fact, and half a fact is not one.
+   */
+  private async finished(fact: string, payload: unknown): Promise<unknown> {
+    let carried = payload;
+    for (const link of this.pipes.get(fact) ?? []) {
+      const facade = this.container.resolve<Record<string, Function>>(link.door);
+      const answered = await facade[link.op]({ ...Invocation.empty, input: carried });
+
+      // A link that answers nothing SUPPRESSES the fact — every subscriber was then handed
+      // `null` and crashed reading it, one message each. It is refused rather than named,
+      // because a fact is what HAPPENED: the announcer already said so and cannot be told
+      // otherwise, `Emit` returning void. Filtering belongs to whoever announces, or to
+      // each reader; it is not a link's to decide for everyone.
+      if (answered === null || answered === undefined) {
+        throw new Error(
+          `${link.door}.${link.op} finishes the fact '${fact}' and answered nothing.\n`
+          + '  A link says what the fact IS, it does not take it back — the announcer has '
+          + 'already said it happened, and nothing can tell it otherwise.\n'
+          + '  Return the fact, amended or as it stands.',
+        );
+      }
+      carried = answered;
+    }
+
+    return carried;
+  }
+
   /**
    * The announcement realizes the fact's own `lifecycle.create` — a `created()` stamped, an id
    * generated, a default applied.
@@ -151,7 +309,7 @@ export class Emissions {
         } catch (cause) {
           throw new Error(`${fact} → ${door} could not be reached`, { cause });
         }
-        return facade[op]({ ...EMPTY_INVOCATION, input: payload });
+        return facade[op]({ ...Invocation.empty, input: payload });
       }),
     }));
   }
@@ -164,3 +322,13 @@ export class Emissions {
       + ` If '${fact}' gained a field, this copy is older than the sender's: re-run \`fougere sync\`.`;
   }
 }
+
+/**
+ * The container key a declared CLASS NAME answers under — `RedactHandler` → `redactHandler`,
+ * the same key `facadeKeyOf` builds from an address.
+ */
+function doorOf(declared: string): string {
+  const key = lowerFirst(declared);
+
+  return key.endsWith('Handler') ? key : `${key}Handler`;
+}