@winkjs/composer 0.5.1 → 0.7.0

package/src/core/utils/callback-guard/index.js

@@ -0,0 +1,176 @@
+// core/utils/callback-guard/index.js
+
+/**
+ * @fileoverview The shared guard for user-supplied callbacks.
+ *
+ * Adapters and the flow runtime hand the user's functions to this
+ * module once, at setup. The armed version they get back contains
+ * every fault the user's code can produce. That covers a plain
+ * throw, a rejected promise, and even a `throw null` with no
+ * message to read. Each fault becomes one classified
+ * CALLBACK_FAILED report. The operation that invoked the callback
+ * continues unharmed. This is ADR-018's callback-isolation rule:
+ * a misbehaving user callback never reaches transport code and
+ * never fails silently. ADR-027 scopes which callbacks are
+ * wrapped: notification callbacks only. A callback whose throw
+ * carries meaning (QuestDB's strict-mode onWarning) and the
+ * flow-guarded onMessage stay unwrapped.
+ *
+ * Design constraints, in force at every call site:
+ * - Wrap once at setup; never per message. The armed closure's
+ *   success-path cost is one try frame and one typeof check. An
+ *   async callback additionally costs one derived promise per
+ *   call — that cost follows the user's own choice of an async
+ *   handler.
+ * - Fixed two-argument signature: every wrapped callback takes at
+ *   most two arguments, so no rest-array is allocated per call.
+ *   A one-argument callback observes a trailing undefined; that is
+ *   deliberate and documented here.
+ * - The fault reporter is throw-proof. Every containment guarantee
+ *   reduces to "reporting a fault cannot itself fault". The report
+ *   closure receives an already-safe detail string, never the raw
+ *   thrown value. When the report closure itself fails, the guard
+ *   falls back to one bare log line with no user-value
+ *   interpolation.
+ * - The fault report is bounded per wrapped callback (ADR-029, the
+ *   bounded loss line). A callback that fails on every call would
+ *   print one line per call, which for a status callback on a busy
+ *   source is a line per message. So the first two faults of an
+ *   episode report in full, later faults are counted, and one summary
+ *   reports per minute with the count. A quiet minute ends the
+ *   episode. The summary goes through the site's own channel with the
+ *   count appended to the detail, so no site changes.
+ */
+
+import { logger } from '../../logger/index.js';
+import { createLineBound } from '../line-rate/index.js';
+
+/** The bound on the fault report (see the file header). */
+const FULL_FAULT_LINES_PER_EPISODE = 2;
+const FAULT_SUMMARY_INTERVAL_MS = 60000;
+
+/**
+ * Frozen sentinel `wrapTransform` returns when the transform threw.
+ * Distinguishes "threw" from the documented null/undefined drop.
+ * Never exported from composer's public surface, so no user value
+ * can ever be identical to it.
+ */
+const TRANSFORM_THREW = Object.freeze( {} );
+
+/**
+ * Renders a thrown value as a safe string. `throw null`, a throwing
+ * `message` getter, and an object with no string form all yield a
+ * printable result instead of a second throw.
+ *
+ * @param {*} err - Whatever the user's code threw or rejected with
+ * @returns {string} A printable detail, never a throw
+ */
+const describeFault = function ( err ) {
+    try {
+        if ( err && err.message ) {
+            return String( err.message );
+        }
+        return String( err );
+    } catch {
+        return 'unprintable error';
+    }
+}; // describeFault()
+
+/**
+ * Last-resort line when the site's own report closure fails. Bare on
+ * purpose: interpolating anything user-controlled here could throw
+ * again, and this is the floor the whole guard stands on.
+ */
+const reportFallback = function () {
+    logger.error( 'winkComposer/callbackGuard: a callback fault report failed [CALLBACK_FAILED]' );
+}; // reportFallback()
+
+/**
+ * Arms one user callback. Returns null when no function was given,
+ * so `if ( onX )` presence checks at the sites keep their meaning
+ * (absent stays absent — no-handler fallbacks are untouched).
+ *
+ * @param {Function} fn - The user's callback, already validated by
+ *   the site's own config validation (validate raw, then wrap)
+ * @param {Object} spec - `{ name, severity, report }`
+ * @param {string} spec.name - Callback name for the report
+ * @param {string} spec.severity - 'red' or 'yellow' per ADR-018:
+ *   red when the callback signals something happening now, yellow
+ *   for post-event reporting
+ * @param {Function} spec.report - Site channel: called as
+ *   `report( severity, name, detail )` with detail already safe
+ * @returns {Function|null} The armed callback, or null
+ */
+const wrapCallback = function ( fn, { name, severity, report } ) {
+    if ( typeof fn !== 'function' ) {
+        return null;
+    }
+    const bounded = createLineBound( {
+        fullLines: FULL_FAULT_LINES_PER_EPISODE,
+        intervalMs: FAULT_SUMMARY_INTERVAL_MS,
+        printFull: report,
+        printSummary: function ( count, seconds, sev, callbackName, detail ) {
+            report( sev, callbackName, `${detail}; ${count} more fault(s) in the last ${seconds} s` );
+        }
+    } );
+    const faultFn = function ( err ) {
+        try {
+            bounded( severity, name, describeFault( err ) );
+        } catch {
+            reportFallback();
+        }
+    };
+    return function ( a, b ) {
+        try {
+            const result = fn( a, b );
+            if ( result && typeof result.then === 'function' ) {
+                // An async callback costs one derived promise per call.
+                // That allocation is proportional to the user's own
+                // choice of an async handler; a sync callback allocates
+                // nothing here.
+                const settled = result.then( undefined, faultFn );
+                // A native promise cannot reject past this point, because
+                // faultFn cannot throw. A non-conforming thenable can
+                // ignore its handlers and RETURN a rejected promise
+                // instead; sink that one level so it cannot leak as an
+                // unhandled rejection. The guard contains bugs, not
+                // in-process adversaries — a deeper chain of hostile
+                // thenables stays the caller's own fault.
+                if ( !( result instanceof Promise ) && settled && typeof settled.then === 'function' ) {
+                    settled.then( undefined, faultFn );
+                }
+            }
+        } catch ( err ) {
+            faultFn( err );
+        }
+    };
+}; // wrapCallback()
+
+/**
+ * Arms a value-returning callback (the sources' `transform`). The
+ * caller keeps its control flow — a transform's return decides the
+ * row's fate — so this face only converts a throw into the sentinel
+ * and a safe fault report. Return-shape checks and the null drop
+ * stay at the site.
+ *
+ * @param {Function} fn - The transform, called as `fn( value )`
+ * @param {Function} onFault - Hoisted site closure, called as
+ *   `onFault( detail, context )` on the failure path only
+ * @returns {Function} `( value, context ) => result | TRANSFORM_THREW`
+ */
+const wrapTransform = function ( fn, onFault ) {
+    return function ( value, context ) {
+        try {
+            return fn( value );
+        } catch ( err ) {
+            try {
+                onFault( describeFault( err ), context );
+            } catch {
+                reportFallback();
+            }
+            return TRANSFORM_THREW;
+        }
+    };
+}; // wrapTransform()
+
+export { wrapCallback, wrapTransform, TRANSFORM_THREW, FULL_FAULT_LINES_PER_EPISODE, FAULT_SUMMARY_INTERVAL_MS };

package/src/core/utils/clock/index.js

@@ -0,0 +1,34 @@
+// core/utils/clock/index.js
+
+/**
+ * @fileoverview The stopwatch clock for time rules that must not
+ * follow the wall clock.
+ *
+ * `Date.now()` reads the wall clock, and the wall clock can step. NTP
+ * corrects a board after boot or after a long time without network,
+ * and an operator can set the time by hand. A rule such as "red after
+ * 30 s disconnected" or "expire a dedup entry after 120 s" would then
+ * fire early or late by the size of the step. `performance.now()`
+ * reads a clock that only counts up, from process start, in
+ * milliseconds with a fraction. A step in the wall clock does not
+ * move it (ADR-018, long-running stability).
+ *
+ * The function reads `globalThis.performance` at every call, for two
+ * reasons. The method must be called on its own object, so the bare
+ * method cannot be passed around as a clock. And a test that fakes the
+ * stopwatch replaces the global object rather than patching the
+ * method, so a captured reference would keep reading the real clock.
+ *
+ * Use this clock for durations and expiry. Use `Date.now()` for
+ * timestamps that leave the process, such as a record's time field.
+ */
+
+/**
+ * Reads the stopwatch clock.
+ *
+ * @returns {number} Milliseconds since process start, with a fraction;
+ *   never decreases.
+ */
+export const monotonicNow = function () {
+    return globalThis.performance.now();
+}; // monotonicNow()

package/src/core/utils/half-life/index.js

@@ -14,7 +14,7 @@
  */
 export const halfLifeToAlpha = function ( halfLife ) {
     if ( typeof halfLife !== 'number' || !Number.isFinite( halfLife ) || ( halfLife <= 0 ) ) {
-        throw new Error( 'Half-life must be a finite number > 0' );
+        throw new Error( 'winkComposer/halfLife: Half-life must be a finite number > 0' );
     }
     // alpha = 1 - exp( -ln(2) / halfLife ); use expm1 to avoid cancellation
     let alpha = -Math.expm1( -( Math.LN2 / halfLife ) );
@@ -37,7 +37,7 @@ export const halfLifeToAlpha = function ( halfLife ) {
  */
 export const alphaToHalfLife = function ( alpha ) {
     if ( typeof alpha !== 'number' || !Number.isFinite( alpha ) || ( alpha <= 0 ) || ( alpha >= 1 ) ) {
-        throw new Error( 'Alpha must be a finite number in (0,1)' );
+        throw new Error( 'winkComposer/halfLife: Alpha must be a finite number in (0,1)' );
     }
     // halfLife = ln(2) / -ln(1 - alpha) ; use log1p(-alpha) for stability
     return Math.LN2 / ( -Math.log1p( -alpha ) );
@@ -53,10 +53,10 @@ export const alphaToHalfLife = function ( alpha ) {
  */
 export const halfLifeToWarmupSamples = function ( halfLifeSamples, settledFraction = 0.95 ) {
     if ( typeof halfLifeSamples !== 'number' || !Number.isFinite( halfLifeSamples ) || ( halfLifeSamples <= 0 ) ) {
-        throw new Error( 'halfLifeSamples must be a finite number > 0' );
+        throw new Error( 'winkComposer/halfLife: halfLifeSamples must be a finite number > 0' );
     }
     if ( typeof settledFraction !== 'number' || !Number.isFinite( settledFraction ) || ( settledFraction <= 0 ) || ( settledFraction >= 1 ) ) {
-        throw new Error( 'settledFraction must be a finite number in (0,1)' );
+        throw new Error( 'winkComposer/halfLife: settledFraction must be a finite number in (0,1)' );
     }
     // nHL = -log2(1 - settledFraction) = -ln(1 - s)/ln2
     const nHalfLives = ( -Math.log1p( -settledFraction ) ) / Math.LN2;

package/src/core/utils/jitter/index.js

@@ -0,0 +1,51 @@
+// core/utils/jitter/index.js
+
+/**
+ * @fileoverview Adds a random share to a reconnect period, once per
+ * client, so a fleet does not retry in step.
+ *
+ * mqtt.js retries at a fixed period. When one broker goes away, every
+ * client that used it fails at the same moment and retries on the same
+ * beat. Attempt `k` from every client lands on the recovering broker
+ * at `k` times the period, all at once. This module gives each client
+ * its own period: the configured one plus a random share of up to a
+ * fifth of it. The share is drawn once at setup, and because attempt
+ * `k` fires at `k` times the period, a fixed offset spreads the fleet
+ * further with each attempt.
+ *
+ * The configured period is the operator's floor. The helper never
+ * shortens it, and a period of zero stays zero, so a reconnect that
+ * was switched off stays off. Both MQTT adapters use this module; the
+ * reconnect loop itself stays the library's (ADR-018).
+ *
+ * The random source is a parameter, so a spec can name its result.
+ * Nothing here runs on a message path.
+ *
+ * @see ADR-018
+ */
+
+/** The largest share of the period the jitter may add. */
+export const RECONNECT_JITTER_FRACTION = 0.2;
+
+/**
+ * Returns the period plus the floor of a random share of it.
+ *
+ * @param {number} periodMs - The configured period, a finite number of milliseconds, zero or more
+ * @param {Object} [options]
+ * @param {number} [options.fraction=RECONNECT_JITTER_FRACTION] - The largest share to add, in `[0, 1]`
+ * @param {Function} [options.random=Math.random] - Returns a number in `[0, 1)`
+ * @returns {number} `periodMs + Math.floor( random() * periodMs * fraction )`
+ * @throws {TypeError} when an argument is out of range
+ */
+export const jitteredPeriod = function ( periodMs, { fraction = RECONNECT_JITTER_FRACTION, random = Math.random } = {} ) {
+    if ( ( typeof periodMs !== 'number' ) || !Number.isFinite( periodMs ) || ( periodMs < 0 ) ) {
+        throw new TypeError( `winkComposer/jitter: periodMs must be a finite number of milliseconds, zero or more, got ${String( periodMs )}` );
+    }
+    if ( ( typeof fraction !== 'number' ) || !( ( fraction >= 0 ) && ( fraction <= 1 ) ) ) {
+        throw new TypeError( `winkComposer/jitter: fraction must be a number in [0, 1], got ${String( fraction )}` );
+    }
+    if ( typeof random !== 'function' ) {
+        throw new TypeError( 'winkComposer/jitter: random must be a function' );
+    }
+    return periodMs + Math.floor( random() * periodMs * fraction );
+}; // jitteredPeriod()

package/src/core/utils/line-rate/index.js

@@ -0,0 +1,104 @@
+// core/utils/line-rate/index.js
+
+/**
+ * @fileoverview Bounds how often a repeating event reaches the log.
+ *
+ * A dead sensor, a stuck callback, or an unreachable database produces
+ * the same event once per row. Printing every one fills a log file with
+ * one line per second for a whole night, and the line that matters is
+ * lost in the repeats. This module keeps the first lines of such an
+ * episode in full and then prints one summary per interval. An episode
+ * is a run of events with no quiet interval between them. A quiet
+ * interval ends the episode, so the next event prints in full again.
+ *
+ * The bound is a pure closure over a stopwatch reading, `monotonicNow`,
+ * so a step in the wall clock can neither end an episode nor move a
+ * summary (ADR-018, long-running stability). It holds no timer, so it
+ * needs no shutdown and cannot keep a process alive. The
+ * summary prints at the next event after the interval, never on a
+ * timer. So a burst that stops shows its count only when the next
+ * episode starts, or never. That is the accepted trade for zero timers.
+ *
+ * Two sites share this shape. The QuestDB adapter's flush-failure loss
+ * line uses the same algorithm inline (ADR-029, the bounded loss line).
+ * The adapter's default row-skip warning and the callback guard's
+ * `CALLBACK_FAILED` line both use this module.
+ */
+
+import { monotonicNow } from '../clock/index.js';
+
+/**
+ * Creates a line bound.
+ *
+ * The returned function takes the event's arguments, up to three, and
+ * forwards them by identity to `printFull` for the first `fullLines`
+ * events of an episode. What the arguments mean is the caller's
+ * business: the callback guard passes a severity, a callback name and
+ * a fault description; the row-skip warning passes a raw value and a
+ * partition id. Later events inside the interval are counted. The
+ * first event a full interval after the last printed line calls
+ * `printSummary` with the count since that line, the seconds elapsed,
+ * and the latest arguments. When an episode ends with counted events,
+ * their summary prints before the next episode's first full line.
+ *
+ * Three named parameters stand in for a rest parameter on purpose. A
+ * rest parameter builds an array on every call, and the row-skip
+ * warning runs once per skipped row.
+ *
+ * @param {Object} options
+ * @param {number} options.fullLines - How many events per episode print in full.
+ * @param {number} options.intervalMs - The summary interval, also the quiet gap that ends an episode.
+ * @param {Function} options.printFull - Called as `printFull( arg1, arg2, arg3 )` with the event's arguments.
+ * @param {Function} options.printSummary - Called as `printSummary( count, seconds, arg1, arg2, arg3 )`.
+ * @returns {Function} `( arg1, arg2, arg3 ) => void`.
+ */
+export const createLineBound = function ( { fullLines, intervalMs, printFull, printSummary } ) {
+    let lastEventAt = 0;
+    let lastLineAt = 0;
+    let printed = 0;
+    let counted = 0;
+
+    // The state clears before the printer runs, as on the full-line
+    // path. A printer that throws then costs that one line only. With
+    // the old order a throw left the count and the stamp behind, and
+    // every later event ran straight into the printer again.
+    const summarize = function ( now, arg1, arg2, arg3 ) {
+        const seconds = Math.round( ( now - lastLineAt ) / 1000 );
+        const count = counted;
+        lastLineAt = now;
+        counted = 0;
+        printSummary( count, seconds, arg1, arg2, arg3 );
+    }; // summarize()
+
+    // The latest arguments are kept for the summary that closes an
+    // episode. They belong to the last counted event, not the new one.
+    let lastArg1;
+    let lastArg2;
+    let lastArg3;
+
+    return function ( arg1, arg2, arg3 ) {
+        const now = monotonicNow();
+        if ( ( now - lastEventAt ) >= intervalMs ) {
+            // A quiet interval ended the previous episode.
+            if ( counted > 0 ) {
+                summarize( now, lastArg1, lastArg2, lastArg3 );
+            }
+            printed = 0;
+        }
+        lastEventAt = now;
+        lastArg1 = arg1;
+        lastArg2 = arg2;
+        lastArg3 = arg3;
+        if ( printed < fullLines ) {
+            printed += 1;
+            lastLineAt = now;
+            printFull( arg1, arg2, arg3 );
+            return;
+        }
+        counted += 1;
+        if ( ( now - lastLineAt ) < intervalMs ) {
+            return;
+        }
+        summarize( now, arg1, arg2, arg3 );
+    };
+}; // createLineBound()

package/src/core/utils/quantize/index.js

@@ -11,24 +11,30 @@
  * for human reading. Both used to carry their own copy of the same
  * formula; this module is the single source.
  *
- * The quantizer pre-computes the inverse resolution and the appropriate
- * decimal-place count at build time, so the per-message hot path is one
- * multiply, one round, one multiply, one `toFixed` — no allocation, no
- * recomputation.
+ * The quantizer chooses its arithmetic once, at build time, so the
+ * per-message hot path is a few float operations and no allocation.
+ * Three shapes of resolution get three paths:
  *
- * Decimal places follow the natural rule:
- * - `resolution = 0.001` → 3 decimal places
- * - `resolution = 0.01`  → 2 decimal places
- * - `resolution = 0.1`   → 1 decimal place
- * - `resolution = 1`     → 0 (returns `null`, signalling passthrough)
- * - `resolution = 5`     → 0 (whole-number resolution; values still
- *                          snap to multiples of 5, but no decimals to
- *                          format)
+ * - The inverse is a whole number (0.1, 0.01, 0.001, 0.25, 0.5, 0.2,
+ *   0.125). The value is `Math.round( v * inverse ) / inverse`. A
+ *   division by an exact whole number is correctly rounded, so it
+ *   returns the nearest double to the grid value: 101 / 10 is 10.1
+ *   and 95 / 4 is 23.75. No string is built.
+ * - The resolution is a whole number (5, 10, 7). The value is
+ *   `Math.round( v / resolution ) * resolution`, exact for whole
+ *   numbers. No string is built.
+ * - Anything else (0.3, 0.15, 2.5). The old path stays: multiply,
+ *   round, multiply, then `toFixed` to trim the noise and `Number` to
+ *   parse it back. The trim keeps as many decimals as the resolution
+ *   itself has. This path allocates one short string per value. It is
+ *   rare: a declared resolution is nearly always a power of ten.
  *
- * The `toFixed` step cleans up floating-point noise — for example,
- * `Math.round( 10.1 * 10 ) * 0.1` produces `10.100000000001` because
- * of IEEE-754 rounding, and `toFixed(1)` returns the tidy `"10.1"`
- * which `Number(...)` parses back to `10.1`.
+ * Why not `toFixed` for everything. `Math.round( 10.1 * 10 ) * 0.1` is
+ * `10.100000000000001`, because 0.1 is not exact in binary, so a
+ * multiply by the resolution needs a trim. The trim built a string per
+ * value on the storage hot path. It also cut grid values short: with a
+ * resolution of 0.25 the trim kept one decimal, so 23.75 became 23.8,
+ * off the grid. Division by the exact inverse has neither problem.
  *
  * Returning `null` for `resolution === 1` (or undefined) is a small but
  * load-bearing optimisation: the common case is "no resolution declared"
@@ -62,9 +68,27 @@ const buildResolutionQuantizer = function ( resolution ) {
     if ( resolution === undefined || resolution === 1 ) return null;
 
     const invResolution = 1 / resolution;
-    const decimalPlaces = resolution < 1 ?
-        Math.ceil( -Math.log10( resolution ) ) :
-        0;
+
+    if ( Number.isInteger( invResolution ) ) {
+        return function ( v ) {
+            return Math.round( v * invResolution ) / invResolution;
+        };
+    }
+
+    if ( Number.isInteger( resolution ) ) {
+        return function ( v ) {
+            return Math.round( v / resolution ) * resolution;
+        };
+    }
+
+    // The string path trims the noise to the decimals the grid needs.
+    // The count comes from the resolution's own digits, so 0.15 gets
+    // two and 2.5 gets one. A resolution below one millionth prints in
+    // exponent form, so it takes the count from its magnitude instead.
+    const text = String( resolution );
+    const decimalPlaces = ( text.indexOf( 'e' ) === -1 ) ?
+        ( text.length - text.indexOf( '.' ) - 1 ) :
+        Math.ceil( -Math.log10( resolution ) );
 
     return function ( v ) {
         const quantized = Math.round( v * invResolution ) * resolution;

package/src/core/utils/validate/composer-validators.js

@@ -1,5 +1,5 @@
 /**
- * WinkComposer-specific validators
+ * winkComposer-specific validators
  * Domain-specific validation functions for streaming analytics nodes
  */
 
@@ -121,7 +121,7 @@ const noSelfTriggers = {
             !trgr.targets.includes( spec.name )
         );
     },
-    error: 'composer/validation: Node cannot trigger control methods on itself'
+    error: 'winkComposer/validation: Node cannot trigger control methods on itself'
 }; // noSelfTriggers
 
 // Export all composer validators

package/src/core/utils/validate/index.js

@@ -1,5 +1,5 @@
 /**
- * WinkComposer validation module
+ * winkComposer validation module
  * Provides schema-based validation for node specifications
  */
 

package/src/core/utils/validate/validate.js

@@ -95,7 +95,7 @@ const validateWithSchema = function ( schema, object, pathPrefix = 'object' ) {
         // Throw if invalid - used in init functions
         throwIfInvalid: ( nodeType ) => {
             if ( !valid ) {
-                const errorMessage = `WinkComposer/${nodeType} validation failed:\n  ${errors.join( '\n  ' )}`;
+                const errorMessage = `winkComposer/${nodeType}: validation failed:\n  ${errors.join( '\n  ' )}`;
                 throw new TypeError( errorMessage );
             }
         }

package/src/core/wiring/assert-handle.js

@@ -17,7 +17,7 @@
  * - Startup runs once per flow; the check costs nothing at runtime.
  *
  * Error message format (same across sinks):
- *   `WinkComposer/adapter: '<adapterId>' missing required method '<name>'`
+ *   `winkComposer/adapter: '<adapterId>' missing required method '<name>'`
  *
  * @see ADR-018 (sink method surface)
  */
@@ -32,23 +32,23 @@
  * @param {*} handle - the value returned from the factory
  * @param {string[]} requiredMethods - method names that must be functions
  *   on the handle (e.g., [ 'publishNow', 'shutdown', 'getHealth' ])
- * @throws {Error} `WinkComposer/adapter: '<adapterId>' factory returned non-object handle`
+ * @throws {Error} `winkComposer/adapter: '<adapterId>' factory returned non-object handle`
  *   if `handle` is null/undefined/non-object.
- * @throws {Error} `WinkComposer/adapter: '<adapterId>' missing required method '<name>'`
+ * @throws {Error} `winkComposer/adapter: '<adapterId>' missing required method '<name>'`
  *   on the first missing or non-function method (fails fast — does not
  *   enumerate every gap, since one is enough to abort wiring).
  */
 const assertHandle = function ( adapterId, handle, requiredMethods ) {
     if ( !handle || typeof handle !== 'object' ) {
         throw new Error(
-            `WinkComposer/adapter: '${adapterId}' factory returned non-object handle`
+            `winkComposer/adapter: '${adapterId}' factory returned non-object handle`
         );
     }
     for ( let i = 0; i < requiredMethods.length; i += 1 ) {
         const name = requiredMethods[ i ];
         if ( typeof handle[ name ] !== 'function' ) {
             throw new Error(
-                `WinkComposer/adapter: '${adapterId}' missing required method '${name}'`
+                `winkComposer/adapter: '${adapterId}' missing required method '${name}'`
             );
         }
     }

package/src/core/wiring/assert-module.js

@@ -19,7 +19,7 @@
  * `src/core/test/adapter-module-surface.specs.js`.
  *
  * Error message format (same shape as assert-handle.js):
- *   `WinkComposer/adapter: '<adapterId>' module missing valid
+ *   `winkComposer/adapter: '<adapterId>' module missing valid
  *    'durabilityClass' export — got <value>; expected one of ...`
  *
  * @see ADR-018 (module surface, durability)
@@ -52,7 +52,7 @@ const assertModuleDurability = function ( adapterId, module ) {
     }
     const got = ( typeof value === 'string' ) ? `'${value}'` : String( value );
     const err = new Error(
-        `WinkComposer/adapter: '${adapterId}' module missing valid 'durabilityClass' export ` +
+        `winkComposer/adapter: '${adapterId}' module missing valid 'durabilityClass' export ` +
         `(ADR-018) — got ${got}; expected one of ` +
         `${DURABILITY_CLASSES.map( ( c ) => `'${c}'` ).join( ' | ' )}`
     );

package/src/core/wiring/wire-emitters.js

@@ -45,6 +45,7 @@
 import { assertHandle } from './assert-handle.js';
 import { assertModuleDurability } from './assert-module.js';
 import { applySemanticsRequirement } from './wire-semantics.js';
+import { logger } from '../logger/index.js';
 
 /**
  * Methods the framework calls on an emitter handle later, so they have to
@@ -53,8 +54,10 @@ import { applySemanticsRequirement } from './wire-semantics.js';
  * contract's method surface.
  * `getPressure` is optional — its presence decides whether the handle is
  * collected into `backpressureAwareSinks`, not whether the wire succeeds.
+ * `flush` is required, as it is for storages: ADR-018 §6 lists it in
+ * the sink floor for both roles.
  */
-const REQUIRED_EMITTER_METHODS = [ 'publishNow', 'shutdown', 'getHealth' ];
+const REQUIRED_EMITTER_METHODS = [ 'publishNow', 'flush', 'shutdown', 'getHealth' ];
 
 /**
  * Serializes a rejection's `dropped` payload for the shutdown log. A
@@ -121,7 +124,7 @@ const emitters = ( function () {
                 const module = emitterModules[ target ];
                 const factory = module && module.createEmitter;
                 if ( typeof factory !== 'function' ) {
-                    throw new Error( `composer: Invalid emitter module: ${target}` );
+                    throw new Error( `winkComposer/wiring: Invalid emitter module: ${target}` );
                 }
 
                 // ADR-018 module-surface check: the module must say what
@@ -234,8 +237,8 @@ const emitters = ( function () {
             if ( result.status === 'rejected' ) {
                 const err = result.reason || {};
                 const dropped = err.dropped ? ` dropped=${describeDropped( err.dropped )}` : '';
-                console.error(
-                    `WinkComposer/wiring: emitter '${names[ i ]}' shutdown failed [${err.code || 'UNKNOWN'}]: ${err.message || String( err )}${dropped}`
+                logger.error(
+                    `winkComposer/wiring: emitter '${names[ i ]}' shutdown failed [${err.code || 'UNKNOWN'}]: ${err.message || String( err )}${dropped}`
                 );
             }
         } );

package/src/core/wiring/wire-linear-graph.js

@@ -11,7 +11,7 @@ const wireLinearGraph = function ( specs, nodeModules, options = {} ) {
         const nodeModule = nodeModules[ moduleName ];
 
         if (!nodeModule) {
-            throw new Error( `composer/wireGraph: Node module '${moduleName}' not found for nodeType '${spec.nodeType}'` );
+            throw new Error( `winkComposer/wiring: Node module '${moduleName}' not found for nodeType '${spec.nodeType}'` );
         }
 
         const nextHops = nextHop ? [ nextHop ] : [];