@winkjs/composer 0.5.1 → 0.6.0

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

@@ -0,0 +1,155 @@
+// 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.
+ */
+
+import { logger } from '../../logger/index.js';
+
+/**
+ * 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 faultFn = function ( err ) {
+        try {
+            report( 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 };

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/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
@@ -121,7 +122,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 +235,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 ] : [];

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

@@ -37,27 +37,27 @@ const wireNode = function ( nodeModule, nodeIndex, nextHops = [], options = {} )
     const maxRecentErrors = options.maxRecentErrors || 5;
     // Validate required node module interface at wire-time
     if ( !nodeModule || typeof nodeModule.update !== 'function' ) {
-        throw new TypeError( `composer/wireNode: Node module must implement update function; found ${typeof nodeModule.update}` );
+        throw new TypeError( `winkComposer/wiring: Node module must implement update function; found ${typeof nodeModule.update}` );
     }
 
     if ( typeof nodeModule.publishTo !== 'function' ) {
-        throw new TypeError( `composer/wireNode: Node module must implement publishTo function; found ${typeof nodeModule.publishTo}` );
+        throw new TypeError( `winkComposer/wiring: Node module must implement publishTo function; found ${typeof nodeModule.publishTo}` );
     }
 
     // Validate next hops are executable functions
     if ( !Array.isArray( nextHops ) ) {
-        throw new TypeError( `composer/wireNode: Next hops must be an array; found ${typeof nextHops}` );
+        throw new TypeError( `winkComposer/wiring: Next hops must be an array; found ${typeof nextHops}` );
     }
 
     for ( let i = 0; i < nextHops.length; i += 1 ) {
         if ( typeof nextHops[ i ] !== 'function' ) {
-            throw new TypeError( `composer/wireNode: Next hop at index ${i} must be a function; found ${typeof nextHops[ i ]}` );
+            throw new TypeError( `winkComposer/wiring: Next hop at index ${i} must be a function; found ${typeof nextHops[ i ]}` );
         }
     }
 
     // Validate node index for state store access
     if ( typeof nodeIndex !== 'number' || nodeIndex < 0 ) {
-        throw new RangeError( `composer/wireNode: Node index must be a non-negative number; found ${nodeIndex}` );
+        throw new RangeError( `winkComposer/wiring: Node index must be a non-negative number; found ${nodeIndex}` );
     }
 
     /**
@@ -142,7 +142,7 @@ const wireNode = function ( nodeModule, nodeIndex, nextHops = [], options = {} )
 
             // Provide node-level error isolation with contextual information
             // This prevents individual node failures from crashing the entire flow
-            const nodeError = new Error( `Node execution failed at index ${nodeIndex}: ${error.message}` );
+            const nodeError = new Error( `winkComposer/wiring: Node execution failed at index ${nodeIndex}: ${error.message}` );
             nodeError.cause = error;
             nodeError.nodeIndex = nodeIndex;
             nodeError.nodeModule = nodeModule.getNodeType ? nodeModule.getNodeType() : 'unknown';

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

@@ -151,7 +151,7 @@ const applySemanticsRequirement = function ( adapterId, module, runtimeAssetClas
             // QuestDB's existing createStorage guard; this layer
             // catches it earlier in the lifecycle.
             const err = new Error(
-                `WinkComposer/wiring: adapter '${adapterId}' declares semanticsRequirement.assetClass.required ` +
+                `winkComposer/wiring: adapter '${adapterId}' declares semanticsRequirement.assetClass.required ` +
                 'but the flow has no .assetClass() — add .assetClass(assetClassDef) to the flow definition'
             );
             err.code = 'MISSING_ASSET_CLASS';

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

@@ -48,6 +48,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 a storage handle later, so they have to
@@ -161,7 +162,7 @@ const storages = ( function () {
 
             const module = storageModules[ storageName ];
             if ( !module?.createStorage ) {
-                throw new Error( `composer: Invalid storage module: ${storageName}` );
+                throw new Error( `winkComposer/wiring: Invalid storage module: ${storageName}` );
             }
 
             // ADR-018 module-surface check: the module must say what a
@@ -322,8 +323,8 @@ const storages = ( function () {
             if ( result.status === 'rejected' ) {
                 const err = result.reason || {};
                 const dropped = err.dropped ? ` dropped=${describeDropped( err.dropped )}` : '';
-                console.error(
-                    `WinkComposer/wiring: storage '${names[ i ]}' shutdown failed [${err.code || 'UNKNOWN'}]: ${err.message || String( err )}${dropped}`
+                logger.error(
+                    `winkComposer/wiring: storage '${names[ i ]}' shutdown failed [${err.code || 'UNKNOWN'}]: ${err.message || String( err )}${dropped}`
                 );
             }
         } );

package/src/flow/driver.js

@@ -24,9 +24,18 @@
  * `processMessage`, exactly as a success does — so `feedAll` counts it as
  * processed. See `docs/handbook/headless-flow.md`.
  *
+ * `err.code` vocabulary (console classification; listed per ADR-018):
+ * - `CALLBACK_FAILED` — the user's `onError` itself threw or rejected.
+ *   The shared callback guard contains the fault (ADR-018): the feed
+ *   loop continues, counters stay truthful, and each fault becomes one
+ *   classified console line carrying the detail.
+ *
  * @see docs/handbook/headless-flow.md
  */
 
+import { wrapCallback } from '../core/utils/callback-guard/index.js';
+import { logger } from '../core/logger/index.js';
+
 /**
  * Default fault handler. Surfaces every fault so none is silent. Allocates only
  * when a fault occurs (rare), never on the success path. Provide your own
@@ -37,7 +46,7 @@
  * @returns {void}
  */
 const logFault = function ( error ) {
-    console.error( `composer/headlessDriver: a message failed — ${error.message}` );
+    logger.error( `winkComposer/headlessDriver: a message failed — ${error.message}` );
 }; // logFault()
 
 /**
@@ -56,18 +65,34 @@ const logFault = function ( error ) {
 const headlessDriver = function ( handle, opts = {} ) {
     if ( !handle || typeof handle.processMessage !== 'function' ) {
         throw new TypeError(
-            'composer/headlessDriver: handle must be the object returned by ' +
+            'winkComposer/headlessDriver: handle must be the object returned by ' +
             'flow(...).run() — it has no processMessage() function'
         );
     }
 
-    const onError = opts.onError === undefined ? logFault : opts.onError;
-    if ( typeof onError !== 'function' ) {
+    const userOnError = opts.onError === undefined ? logFault : opts.onError;
+    if ( typeof userOnError !== 'function' ) {
         throw new TypeError(
-            'composer/headlessDriver: onError must be a function'
+            'winkComposer/headlessDriver: onError must be a function'
         );
     }
 
+    // Armed once at construction (validate raw first, then wrap). The
+    // fault reporter is user code too, so it gets the same containment
+    // as the messages it reports on. ADR-018's rule: a misbehaving
+    // user callback never interrupts the operation that invoked it.
+    // A throwing or rejecting onError costs one classified console
+    // line. The feed continues and the counters stay truthful.
+    const onError = wrapCallback( userOnError, {
+        name: 'onError',
+        severity: 'red',
+        report: function ( severity, name, detail ) {
+            logger.error(
+                `winkComposer/headlessDriver: user callback ${name} failed [CALLBACK_FAILED]: ${detail}`
+            );
+        }
+    } );
+
     /**
      * Feed one message. Use this for push sources, where an event hands you a
      * message and there is no loop to own.
@@ -123,7 +148,7 @@ const headlessDriver = function ( handle, opts = {} ) {
         const isSync = typeof source?.[ Symbol.iterator ] === 'function';
         if ( !isAsync && !isSync ) {
             throw new TypeError(
-                'composer/headlessDriver.feedAll: source must be a sync or async ' +
+                'winkComposer/headlessDriver.feedAll: source must be a sync or async ' +
                 'iterable (an array, a generator, or a stream)'
             );
         }

package/src/flow/expand-single-input-array.js

@@ -12,12 +12,12 @@ const expandXOutputsOptions = function ( meta, nodeArgs, flowState ) {
         const param = inputs[ i ];
 
         if ( seenX[ param ] === 1 ) {
-            throw new Error( `WinkComposer/flow: duplicate input found: '${param}'.` );
+            throw new Error( `winkComposer/flow: duplicate input found: '${param}'.` );
         }
         seenX[ param ] = 1;
 
         const instName = `${baseName}_${param}`;
-        if ( isNodeNameDuplicate( instName ) ) throw Error( `WinkComposer/flow: duplicate node ${instName} found.` );
+        if ( isNodeNameDuplicate( instName ) ) throw Error( `winkComposer/flow: duplicate node ${instName} found.` );
         const stats = Object.create( null );
         for ( const st in outputs ) {
             if (Object.prototype.hasOwnProperty.call( outputs, st ) ) {
@@ -47,12 +47,12 @@ const expandXOptions = function ( meta, nodeArgs, flowState ) {
         const param = inputs[ i ];
 
         if ( seenX[ param ] === 1 ) {
-            throw new Error( `WinkComposer/flow: duplicate input found: '${param}'.` );
+            throw new Error( `winkComposer/flow: duplicate input found: '${param}'.` );
         }
         seenX[ param ] = 1;
 
         const instName = `${baseName}_${param}`;
-        if ( isNodeNameDuplicate( instName ) ) throw Error( `WinkComposer/flow: duplicate node ${instName} found.` );
+        if ( isNodeNameDuplicate( instName ) ) throw Error( `winkComposer/flow: duplicate node ${instName} found.` );
 
         const spec = meta.buildSpec( instName, param, ...balanceArgs );
         specs.push( spec );

package/src/flow/flow-api-schemas.js

@@ -226,7 +226,7 @@ export const validateFlowConfig = function ( config, schema, methodName ) {
             valid: false,
             errors,
             throwIfInvalid: () => {
-                throw new Error( `WinkComposer/flow.${methodName}: ${errors[ 0 ]}` );
+                throw new Error( `winkComposer/flow.${methodName}: ${errors[ 0 ]}` );
             }
         };
     }
@@ -241,7 +241,7 @@ export const validateFlowConfig = function ( config, schema, methodName ) {
         throwIfInvalid: () => {
             if ( !validation.valid ) {
                 throw new Error(
-                    `WinkComposer/flow.${methodName}: validation failed:\n  - ${validation.errors.join( '\n  - ' )}`
+                    `winkComposer/flow.${methodName}: validation failed:\n  - ${validation.errors.join( '\n  - ' )}`
                 );
             }
         }
@@ -266,7 +266,7 @@ export const validateFlowArrayConfig = function ( config, schema, methodName ) {
             valid: false,
             errors,
             throwIfInvalid: () => {
-                throw new Error( `WinkComposer/flow.${methodName}: ${errors[ 0 ]}` );
+                throw new Error( `winkComposer/flow.${methodName}: ${errors[ 0 ]}` );
             }
         };
     }
@@ -280,7 +280,7 @@ export const validateFlowArrayConfig = function ( config, schema, methodName ) {
         throwIfInvalid: () => {
             if ( !validation.valid ) {
                 throw new Error(
-                    `WinkComposer/flow.${methodName}: validation failed:\n  - ${validation.errors.join( '\n  - ' )}`
+                    `winkComposer/flow.${methodName}: validation failed:\n  - ${validation.errors.join( '\n  - ' )}`
                 );
             }
         }