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

package/src/wire/binding.ts

@@ -11,6 +11,12 @@ type ParamSource =
   | { kind: 'collector'; typeName: string }
   /** `Fact<PostPublished>` — something that happened, not something a caller typed. */
   | { kind: 'fact'; factName: string }
+  /**
+   * `Pipe<PostPublished>` — the same thing, BEFORE it is final: what this op answers is
+   * the fact every subscriber then receives. The core has one such link already
+   * (`Emissions.stamped`, which realizes `created()`); this is the declared form of it.
+   */
+  | { kind: 'pipe'; factName: string }
   | { kind: 'param'; name: string; coerce?: 'number' | 'boolean' }
   | { kind: 'input' }
   | { kind: 'context' }
@@ -49,14 +55,19 @@ export function computeBindingPlan(
     // `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' as const, factName: lowerFirst(factOf) },
+        source: {
+          kind: (param.type.name === 'Pipe' ? 'pipe' : 'fact') as 'pipe' | 'fact',
+          factName: lowerFirst(announced),
+        },
         optional: param.optional ?? false,
       };
     }

package/src/wire/emit.ts

@@ -1,32 +1,84 @@
 /** Announcing a fact — the half of the topology `remotes:` never covered. */
 import { lowerFirst } from '@fougere/schema';
 
-/** What an emitter injects. */
-export type Emit<T> = (fact: T) => Promise<void>;
+/**
+ * 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 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 function emitKeyOf(fact: string): string {
   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: string): string {
+  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: string): string | undefined {
-  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: string): string | undefined {
+  return behind(key, AWAIT_SUFFIX);
+}
+
+function behind(key: string, suffix: string): string | undefined {
+  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: readonly { deps: readonly string[] }[]): string[] {
+  return factsIn(handlers, factOfEmitKey);
+}
+
+/** What a set of handlers announces AND WAITS FOR — the same reading, one suffix apart. */
+export function factsAwaitedBy(handlers: readonly { deps: readonly string[] }[]): string[] {
+  return factsIn(handlers, factOfAwaitKey);
+}
+
+function factsIn(
+  handlers: readonly { deps: readonly string[] }[],
+  behindKey: (key: string) => string | undefined,
+): string[] {
   return [...new Set(
     handlers
       .flatMap((handler) => handler.deps)
-      .map(factOfEmitKey)
+      .map(behindKey)
       .filter((fact): fact is string => fact !== undefined),
   )];
 }

package/src/wire/loggerMiddleware.ts

@@ -3,10 +3,16 @@
  */
 import type { AppMiddleware } from './middleware.js';
 import type { Logger } from '../builtin/logger.js';
+import { CARRIES_LINE } from '../builtin/LogLine.js';
 
 /** Create a logger middleware that logs operation entry, exit, and errors. */
 export function loggerMiddleware(logger: Logger): AppMiddleware {
   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 {