@winkjs/composer 0.0.2 → 0.4.1

package/src/nodes/transform/helpers.js

@@ -0,0 +1,39 @@
+/**
+ * @fileoverview Pre-built transform helpers — pure math primitives.
+ *
+ * Each helper is a single-argument pure function suitable for the
+ * transform node's `using` option. Helpers carry a `.semantics`
+ * property for introspection, consistent with tunable helpers.
+ *
+ * @example
+ * import { square, abs } from '@winkjs/composer';
+ * .transform( 'sq', 'ecgDeriv', { result: 'ecgSquared' }, { using: square } )
+ */
+
+/** Squares the input: x * x */
+export const square = ( x ) => ( x * x );
+square.semantics = { type: 'transform', name: 'square', formula: 'x * x' };
+
+/** Absolute value: |x| */
+export const abs = ( x ) => Math.abs( x );
+abs.semantics = { type: 'transform', name: 'abs', formula: '|x|' };
+
+/** Square root: √x (NaN if x < 0) */
+export const sqrt = ( x ) => Math.sqrt( x );
+sqrt.semantics = { type: 'transform', name: 'sqrt', formula: '√x' };
+
+/** Natural logarithm: ln(x) (-Infinity if x = 0, NaN if x < 0) */
+export const log = ( x ) => Math.log( x );
+log.semantics = { type: 'transform', name: 'log', formula: 'ln(x)' };
+
+/** Base-10 logarithm: log₁₀(x) (-Infinity if x = 0, NaN if x < 0) */
+export const log10 = ( x ) => Math.log10( x );
+log10.semantics = { type: 'transform', name: 'log10', formula: 'log₁₀(x)' };
+
+/** Reciprocal: 1/x (Infinity if x = 0) */
+export const reciprocal = ( x ) => ( 1 / x );
+reciprocal.semantics = { type: 'transform', name: 'reciprocal', formula: '1/x' };
+
+/** Negation: -x */
+export const negate = ( x ) => ( -x );
+negate.semantics = { type: 'transform', name: 'negate', formula: '-x' };

package/src/nodes/transform/index.js

@@ -0,0 +1,15 @@
+/**
+ * @fileoverview Transform node — applies a user-supplied pure function
+ * to each sample: result = using( x ).
+ */
+
+export { default as init } from './init.js';
+export { default as update } from './update.js';
+export { default as reset } from './reset.js';
+export { default as recompute } from './recompute.js';
+export { default as publishTo } from './publish-to.js';
+export { default as disable } from '../../core/utils/node/disable.js';
+export { default as enable } from '../../core/utils/node/enable.js';
+export { default as pause } from '../../core/utils/node/pause.js';
+export { default as unpause } from '../../core/utils/node/unpause.js';
+export * from './introspect.js';

package/src/nodes/transform/init.js

@@ -0,0 +1,35 @@
+/**
+ * @fileoverview Initialization for the transform node.
+ *
+ * Validates the spec and creates a minimal state object. The user-supplied
+ * function (`using`) is stored as a direct reference — it is fixed at init
+ * time and not wrapped as a tunable.
+ */
+
+import { validateSpec } from '../../core/utils/node/index.js';
+import * as introspect from './introspect.js';
+
+const init = function ( spec ) {
+    validateSpec( spec, introspect );
+
+    const state = Object.create( null );
+
+    // Standard flags
+    state.inputValidationFailed = false;
+    state.disable = false;
+    state.pause = false;
+
+    // Configuration from spec
+    state.x = spec.from.x;
+    state.stats = spec.stats;
+    state.using = spec.using;
+
+    // Pre-allocate output slot
+    state.result = 0;
+
+    state.nodeType = introspect.getNodeType();
+
+    return state;
+}; // init()
+
+export default init;

package/src/nodes/transform/introspect.js

@@ -0,0 +1,118 @@
+/**
+ * @fileoverview Introspection metadata for the transform node.
+ *
+ * Applies a user-supplied pure function to each sample: result = using( x ).
+ * The function is fixed at init time and receives a single numeric value.
+ * Transform-produced NaN (e.g. sqrt of negative) flows naturally downstream;
+ * only genuine input validation failures set the health flag.
+ *
+ * DSL: .transform( 'sq', 'ecgDeriv', { result: 'ecgSquared' }, { using: square } )
+ */
+
+import { validators } from '../../core/utils/validate/index.js';
+
+// ── Supported Features ──────────────────────────────────────────
+
+const SUPPORTED_STATS = [ 'result' ];
+
+const STAT_DESCRIPTIONS = {
+    result: 'Transformed value: using(x)'
+};
+
+const SUPPORTED_CONTROL_METHODS = {
+    reset: 'Clears accumulated state and restarts computation',
+    enable: 'Enables node processing',
+    disable: 'Disables node processing',
+    pause: 'Pauses node processing while keeping state visible',
+    unpause: 'Resumes node processing after pause'
+};
+
+const NODE_TYPE = 'Transform';
+
+const CAPABILITIES = {
+    description: 'Applies a user-supplied pure function to each sample',
+    features: [
+        'Applies a pure function to each sample: result = using(x)',
+        'Validates input for NaN/Infinity; transform-produced NaN flows naturally downstream',
+        'Ships with pre-built helpers: square, abs, sqrt, log, log10, reciprocal, negate'
+    ]
+};
+
+// ── Default Options ─────────────────────────────────────────────
+
+export const DEFAULT_OPTIONS = Object.create( null );
+
+// ── Getter Functions (defensive copies) ─────────────────────────
+
+export const getSupportedStats = () => SUPPORTED_STATS.slice();
+export const getStatDescriptions = () => ( { ...STAT_DESCRIPTIONS } );
+export const getSupportedControlMethods = () => ( { ...SUPPORTED_CONTROL_METHODS } );
+export const getNodeType = () => NODE_TYPE;
+export const getCapabilities = () => ( {
+    ...CAPABILITIES,
+    features: CAPABILITIES.features.slice()
+} );
+
+// ── DSL Metadata ────────────────────────────────────────────────
+
+const DSL_METADATA = {
+    specSchema: {
+        nodeType: {
+            type: 'string',
+            required: true,
+            value: NODE_TYPE
+        },
+        name: {
+            type: 'string',
+            required: true,
+            validator: validators.identifier,
+            error: 'Name must be a valid identifier'
+        },
+        from: {
+            type: 'object',
+            required: true,
+            properties: {
+                x: {
+                    type: 'string',
+                    required: true,
+                    validator: validators.noSpaces,
+                    error: 'Field name cannot contain spaces'
+                }
+            }
+        },
+        stats: {
+            type: 'object',
+            required: true,
+            propertyNames: SUPPORTED_STATS,
+            propertySchema: {
+                type: 'object',
+                required: true,
+                properties: {
+                    storeAs: {
+                        type: 'string',
+                        required: true,
+                        minLength: 1,
+                        validator: validators.identifier,
+                        error: 'storeAs must be a valid identifier'
+                    }
+                }
+            }
+        },
+        using: {
+            type: 'function',
+            required: true,
+            arity: 1,
+            error: '"using" must be a pure function with exactly one parameter'
+        }
+    },
+
+    buildSpec: ( name, x, stats, options ) => ( {
+        nodeType: NODE_TYPE,
+        name,
+        from: { x },
+        stats,
+        ...options
+    } )
+};
+
+export const getDSLMetadata = () => ( { ...DSL_METADATA } );

package/src/nodes/transform/publish-to.js

@@ -0,0 +1,23 @@
+/**
+ * @fileoverview Publish-to function for the transform node.
+ *
+ * Copies the computed result to the output message. When input
+ * validation failed, publishes NaN via the standard helper.
+ * When the transform produced NaN (e.g. sqrt of negative),
+ * the NaN flows through naturally — no flag, no special handling.
+ */
+
+import { publishNaN } from '../../core/utils/node/index.js';
+
+const publishTo = function ( state, msg ) {
+    if ( state.disable ) return;
+
+    if ( state.inputValidationFailed ) {
+        publishNaN( state, msg );
+        return;
+    }
+
+    msg[ state.stats.result.storeAs ] = state.result;
+}; // publishTo()
+
+export default publishTo;

package/src/nodes/transform/recompute.js

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview Recompute function for the transform node.
+ *
+ * No numerical stability concerns — the node is stateless with
+ * no accumulators, running sums, or recursive filters.
+ */
+
+const recompute = function () {
+    return true;
+}; // recompute()
+
+export default recompute;

package/src/nodes/transform/reset.js

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview Reset function for the transform node.
+ *
+ * No accumulated state to clear — the node is stateless.
+ */
+
+const reset = function () {
+    return true;
+}; // reset()
+
+export default reset;

package/src/nodes/transform/update.js

@@ -0,0 +1,32 @@
+/**
+ * @fileoverview Update function for the transform node.
+ *
+ * Applies the user-supplied pure function to the input value.
+ * Input validation uses the standard `inputValidationFailed` flag.
+ * Transform-produced NaN (e.g. sqrt of negative) is NOT flagged —
+ * the node is healthy; the math produced NaN. Downstream nodes
+ * catch it via their own input validation.
+ */
+
+const update = function ( state, msg ) {
+    if ( state.disable || state.pause ) return state;
+
+    state.inputValidationFailed = false;
+
+    const xVal = msg[ state.x ];
+
+    if ( !Number.isFinite( xVal ) ) {
+        state.inputValidationFailed = true;
+        return state;
+    }
+
+    try {
+        state.result = state.using( xVal );
+    } catch {
+        state.result = NaN;
+    }
+
+    return state;
+}; // update()
+
+export default update;

package/src/nodes/trend/compute-confidence.js

@@ -0,0 +1,112 @@
+// nodes/trend/compute-confidence.js
+
+const computeConfidence = function ( state ) {
+    // During warmup: linear ramp from 0 to 1 based on sample count
+    // Provides gradual trust building as statistics stabilize
+    if ( state.samples < state.warmupSamples ) {
+        const ramp = state.samples / Math.max( state.warmupSamples, 1 );
+        return ( ramp < 0 ) ? 0 : ( ramp > 1 ? 1 : ramp );
+    }
+
+    const epsilon = state.epsilon ?? 1e-12;
+
+    // Prevent division by zero while preserving user's threshold intent
+    // If threshold is 0, user wants to detect ANY change, so use tiny epsilon
+    const safeThreshold = ( state.rocThreshold > 0 ) ? state.rocThreshold : epsilon;
+
+    // Compute noise level (standard deviation) with numerical safety
+    // Variance can be 0 for perfectly stable signals or negative due to numerical errors
+    const rawStd = Math.sqrt( Math.max( state.rocVariance, 0 ) );
+    const stddev = ( rawStd > epsilon ) ? rawStd : epsilon;
+
+    // Persistence: rewards consistent state classification
+    // tanh(x/5) gives: 0.2 at 1 sample, 0.76 at 5, 0.999 at 20
+    const persistence = Math.tanh( state.consistentSamples / 5 );
+    const persistenceFactor = ( 0.5 + ( 0.5 * persistence ) );
+    const absRoCMean = Math.abs( state.rocMean );
+
+    if ( state.trend === 'stable' ) {
+        // STABLE CONFIDENCE: "How confident are we that this is truly stable?"
+
+        // Quietness factor: confidence that noise won't cause false trends
+        // - When stddev << threshold: q ≈ 0, quietness ≈ 1 (high confidence)
+        // - When stddev ≈ threshold: q ≈ 1, quietness ≈ 0.5 (uncertain)
+        // - When stddev >> threshold: q >> 1, quietness ≈ 0 (no confidence)
+        // Quadratic denominator provides smooth, intuitive decay
+        const q = stddev / safeThreshold;
+        const quietness = 1 / ( 1 + ( q * q ) );
+
+        // Margin factor: confidence we're not near the threshold boundary
+        // - At roc = 0: margin = 1 (center of stable zone)
+        // - At roc = threshold: margin = 0 (edge of stability)
+        // This prevents high confidence when hovering near transition
+        const r = absRoCMean / safeThreshold;
+        const margin = 1 - Math.min( 1, r );
+
+        // Combine factors: far from edge AND low noise AND persistent = high confidence
+        const confStable = margin * quietness * persistenceFactor;
+        return ( confStable < 0 ) ? 0 : ( confStable > 1 ? 1 : confStable );
+    }
+
+    // TRENDING CONFIDENCE: "How confident are we in this trend direction?"
+
+    // Signal clarity: signal-to-noise ratio of the *mean roc estimate*.
+    //
+    // The per-sample SNR (|rocMean| / stddev) answers: "is each individual
+    // roc sample clearly positive?" But the relevant question for trend
+    // confidence is: "given all the samples I've seen, is the *average*
+    // roc clearly positive?"
+    //
+    // The standard error of the EWMA mean is stddev / sqrt(n_eff), where
+    // n_eff ≈ (2 / alpha) - 1 is the effective sample size of the EWMA.
+    // Scaling by sqrt(n_eff) converts per-sample SNR to mean-estimate SNR.
+    //
+    // Example: per-sample SNR = 0.5 with n_eff = 35 gives
+    //   SNR_mean = 0.5 × sqrt(35) ≈ 2.96 → signalClarity ≈ 0.76
+    //   vs. signalClarity ≈ 0.16 without the correction.
+    //
+    // Cap n_eff at actual post-warmup samples to avoid over-confidence early.
+    const nEff = Math.min( ( 2 / state.rocAlpha ) - 1, state.samples - state.warmupSamples );
+    const safeNEff = ( nEff > 1 ) ? nEff : 1;
+    state.snr = ( absRoCMean / stddev ) * Math.sqrt( safeNEff );
+    const signalClarity = Math.tanh( state.snr / 3 );
+
+    // Boundary clarity: how far above the classification threshold?
+    // - Just above (roc ≈ 1.1×threshold): overshoot ≈ 0.1, clarity ≈ 0.1
+    // - Well above (roc = 2×threshold): overshoot = 1, clarity ≈ 0.76
+    // - Far above (roc = 5×threshold): overshoot = 4, clarity ≈ 0.999
+    // Using threshold-normalized ratio makes this parameter-agnostic
+    const overshoot = Math.max( 0, ( absRoCMean / safeThreshold ) - 1 );
+    const boundaryClarity = Math.tanh( overshoot );
+
+    // For trending states, we intentionally DO NOT apply the quietness penalty.
+    // Here's why:
+    //
+    // The quietness factor (1/(1+q²) where q = stddev/threshold) was designed to
+    // penalize high noise relative to the threshold. This makes sense for STABLE
+    // states where we want confidence that noise won't cause false trend detection.
+    //
+    // However, for TRENDING states, applying quietness creates redundant penalties:
+    // 1. signalClarity already accounts for noise via SNR (signal/noise ratio)
+    // 2. boundaryClarity ensures we're sufficiently above the threshold
+    //
+    // Adding quietness on top would triple-penalize for noise, causing even strong
+    // trends (SNR > 20) to have low confidence if stddev happens to be comparable
+    // to the threshold. This is overly conservative.
+    //
+    // Example: A perfect linear trend with roc=1.0, threshold=0.1, stddev=0.15
+    // - SNR = 6.7 (excellent signal!)
+    // - boundaryClarity = tanh(9) ≈ 1.0 (far above threshold!)
+    // - But quietness = 1/(1+1.5²) = 0.31 (harsh penalty)
+    // - Result: confidence = 0.31 instead of ~0.9
+    //
+    // For trending states, if the SNR is high and we're well above threshold,
+    // the absolute noise level is less relevant - the trend is clearly real.
+    // Therefore, we omit the quietness factor for rising/falling states.
+    const confTrend = signalClarity * boundaryClarity * persistenceFactor;
+
+    // Ensure output is strictly in [0,1] despite numerical errors
+    return ( confTrend < 0 ) ? 0 : ( confTrend > 1 ? 1 : confTrend );
+}; // computeConfidence()
+
+export { computeConfidence };

package/src/nodes/trend/index.js

@@ -0,0 +1,14 @@
+// nodes/trend/index.js
+
+export { default as init } from './init.js';
+export { default as update } from './update.js';
+export { default as reset } from './reset.js';
+export { default as recompute } from './recompute.js';
+export { default as publishTo } from './publish-to.js';
+// Direct imports for common control functions
+export { default as disable } from '../../core/utils/node/disable.js';
+export { default as enable } from '../../core/utils/node/enable.js';
+export { default as pause } from '../../core/utils/node/pause.js';
+export { default as unpause } from '../../core/utils/node/unpause.js';
+// Re-export everything from introspection.js
+export * from './introspect.js';

package/src/nodes/trend/init.js

@@ -0,0 +1,81 @@
+// nodes/trend/init.js
+
+import { validateWithSchema } from '../../core/utils/validate/index.js';
+import { getDSLMetadata, getNodeType, DEFAULT_OPTIONS } from './introspect.js';
+import { halfLifeToAlpha, halfLifeToWarmupSamples } from '../../core/utils/half-life/index.js';
+import { resolveScalar } from '../../core/utils/options/resolve-field-keyed.js';
+import { asTunable } from '../../core/tunable/index.js';
+
+const init = function ( spec ) {
+    // Validate specification
+    const metadata = getDSLMetadata();
+    const validation = validateWithSchema(
+        {
+            ...metadata.specSchema,
+            _crossFieldValidators: metadata.crossFieldValidators
+        },
+        spec,
+        'spec'
+    );
+    validation.throwIfInvalid( getNodeType() );
+
+    // Create state after validation passes
+    const state = Object.create( null );
+    // Standard input parameter health flag during update: false means healthy
+    state.inputValidationFailed = false;
+    // Ensure node is enabled by default
+    state.disable = false;
+    state.pause = false;
+
+    // Core configuration
+    state.x = spec.from.x;
+    state.stats = spec.stats;
+
+    // Apply parameters with defaults (validation doesn't enforce them)
+    // Supports direct, field-keyed, and tunable specification for tunable params
+    const rocStatsHalfLifeSpec = resolveScalar( spec.rocStatsHalfLife, state.x );
+    const rocThresholdSpec = resolveScalar( spec.rocThreshold, state.x );
+    const speedUpSpec = resolveScalar( spec.speedUp, state.x );
+    const warmupSamplesSpec = resolveScalar( spec.warmupSamples, state.x );
+
+    // Structural params (affect derived values at init time)
+    state.rocStatsHalfLife = rocStatsHalfLifeSpec ?? DEFAULT_OPTIONS.rocStatsHalfLife;
+    state.rocAlpha = halfLifeToAlpha( state.rocStatsHalfLife );
+    state.speedUp = speedUpSpec ?? DEFAULT_OPTIONS.speedUp;
+    state.warmupSamples = warmupSamplesSpec ?? halfLifeToWarmupSamples( state.rocStatsHalfLife, 0.8 );
+    state.warmupSamplesForAccel = Math.ceil( state.warmupSamples * 1.5 );
+
+    // rocThreshold supports tunable for phase-dependent sensitivity
+    state.rocThresholdFn = asTunable( rocThresholdSpec ?? DEFAULT_OPTIONS.rocThreshold );
+    state.rocThreshold = DEFAULT_OPTIONS.rocThreshold;
+    state.tunableErrorLogged = false;
+
+    state.previousValue = null;
+
+    // roc statistics
+    state.rocMean = 0;
+    state.rocVariance = 0;
+
+    // Acceleration hint configuration
+    if ( state.stats.accelerationHint ) {
+        state.rocSmoothedFast = 0;
+        state.accelAlpha = halfLifeToAlpha( state.rocStatsHalfLife / state.speedUp );
+        state.accelerationHint = null;
+    }
+
+    // Tracking
+    state.samples = 0;
+    state.consistentSamples = 0;
+    state.trend = 'learning';
+    state.previousTrend = 'learning';
+    state.confidence = 0;
+    state.snr = 0;
+    // accelThreshold is derived from rocThreshold at runtime (rocThreshold may be dynamic)
+
+    // Node metadata
+    state.nodeType = getNodeType();
+
+    return state;
+}; // init()
+
+export default init;

package/src/nodes/trend/introspect.js

@@ -0,0 +1,151 @@
+// nodes/trend/introspect.js
+
+import { validators } from '../../core/utils/validate/index.js';
+
+/** Single source of truth for what this plugin can do */
+const SUPPORTED_STATS = [
+    'trend',
+    'confidence',
+    'rocMean',
+    'accelerationHint'
+];
+
+/** Human-readable descriptions (for introspection) */
+const STAT_DESCRIPTIONS = {
+    trend: 'Trend direction: learning, stable, rising, or falling',
+    confidence: 'Confidence score between 0 and 1',
+    rocMean: 'Mean Rate of change (first derivative)',
+    accelerationHint: 'Acceleration hint: likely_accelerating, likely_decelerating, or null'
+};
+
+/** Control methods available for triggers */
+const SUPPORTED_CONTROL_METHODS = {
+    reset: 'Clears accumulated state and restarts computation',
+    enable: 'Enables node processing',
+    disable: 'Disables node processing',
+    pause: 'Pauses node processing while keeping state visible',
+    unpause: 'Resumes node processing after pause'
+};
+
+/** The type of this node */
+const NODE_TYPE = 'Trend';
+
+/** Node capabilities for documentation */
+const CAPABILITIES = {
+    description: 'Rate Of Change-domain (first-difference) trend detection with exponentially smoothed roc statistics; no internal smoothing for clean composability.',
+    features: [
+        'States: learning, stable, rising, falling',
+        'Confidence: SNR × persistence (tanh mapping)',
+        'Domain knob: rocThreshold (set ≳ noise of the roc signal)',
+        'Optional acceleration hint (fast/slow EWMAs on roc, gated)',
+        'Warm-up derived from roc half-life'
+    ]
+};
+
+// Export functions for accessing metadata
+export const getSupportedStats = () => SUPPORTED_STATS.slice();
+export const getStatDescriptions = () => ( { ...STAT_DESCRIPTIONS } );
+export const getSupportedControlMethods = () => ( { ...SUPPORTED_CONTROL_METHODS } );
+export const getNodeType = () => NODE_TYPE;
+export const getCapabilities = () => ( { ...CAPABILITIES, features: CAPABILITIES.features.slice() } );
+
+// Spec default values
+export const DEFAULT_OPTIONS = {
+    rocStatsHalfLife: 9,
+    rocThreshold: 0.1,
+    speedUp: 2
+};
+
+/** Parameters that support tunable (dynamic) values */
+export const TUNABLE_PARAMS = [ 'rocThreshold' ];
+
+// DSL Metadata for transpilation
+const DSL_METADATA = {
+    specSchema: {
+        nodeType: {
+            type: 'string',
+            required: true,
+            value: NODE_TYPE
+        },
+        name: {
+            type: 'string',
+            required: true,
+            validator: validators.identifier,
+            error: 'Name must be a valid identifier'
+        },
+        from: {
+            type: 'object',
+            required: true,
+            properties: {
+                x: {
+                    type: 'string',
+                    required: true,
+                    validator: validators.noSpaces,
+                    error: 'Field name cannot contain spaces'
+                }
+            }
+        },
+        stats: {
+            type: 'object',
+            required: true,
+            minProperties: 1,
+            propertyNames: SUPPORTED_STATS,
+            propertySchema: {
+                type: 'object',
+                properties: {
+                    storeAs: {
+                        type: 'string',
+                        required: true,
+                        validator: validators.identifier,
+                        error: 'storeAs must be a valid identifier'
+                    }
+                }
+            }
+        },
+        rocStatsHalfLife: {
+            type: 'numberOrFieldKeyed',
+            required: false,
+            default: DEFAULT_OPTIONS.rocStatsHalfLife,
+            min: 2,
+            validator: validators.positive,
+            error: 'roc stats half-life must be minimum 2'
+        },
+        rocThreshold: {
+            type: 'numberOrFunctionOrFieldKeyed',
+            required: false,
+            default: DEFAULT_OPTIONS.rocThreshold,
+            // Supports tunable for phase-dependent sensitivity (warmup vs steady-state)
+            validator: validators.nonNegativeOrFunction,
+            error: 'Threshold must be non-negative or function'
+        },
+        warmupSamples: {
+            type: 'numberOrFieldKeyed',
+            required: false,
+            integer: true,
+            min: 3,
+            validator: validators.positiveInteger,
+            error: 'Warmup samples must be at least 3'
+        },
+        speedUp: {
+            type: 'numberOrFieldKeyed',
+            required: false,
+            default: DEFAULT_OPTIONS.speedUp,
+            validator: validators.inRange( 1.5, 3 ),
+            error: 'speedUp must be between 1.5 and 3'
+        }
+    },
+
+    crossFieldValidators: [],
+
+    // Pattern: NAME_X_OUTPUTS_OPTIONS -> (name, x, stats, options)
+    buildSpec: ( name, x, stats, options ) => ( {
+            nodeType: NODE_TYPE,
+            name,
+            from: { x },
+            stats,
+            ...options
+    } ),
+
+};
+
+export const getDSLMetadata = () => ( { ...DSL_METADATA } );

package/src/nodes/trend/publish-to.js

@@ -0,0 +1,22 @@
+// nodes/trend/publish-to.js
+
+import { publishNaN } from '../../core/utils/node/index.js';
+
+const publishTo = function ( state, msg ) {
+    if ( state.disable ) return;
+    // Propagate NaN if unhealthy
+    if ( state.inputValidationFailed ) {
+        publishNaN( state, msg );
+        return;
+    }
+
+    // Iterate only over configured stats
+    const stats = state.stats;
+    for ( const statName in stats ) {
+        if ( Object.prototype.hasOwnProperty.call(stats, statName ) ) {
+            msg[ stats[ statName ].storeAs ] = state[ statName ];
+        }
+    }
+}; // publishTo()
+
+export default publishTo;