@winkjs/composer 0.0.2 → 0.4.1

package/src/core/utils/console-formatter/index.js

@@ -0,0 +1,207 @@
+/**
+ * Console Formatter for WinkComposer
+ *
+ * Provides rich, colored console output with structured formatting
+ * for development, debugging, and edge device monitoring.
+ */
+
+// ANSI color codes for terminal output
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+
+    // Foreground colors
+    black: '\x1b[30m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    gray: '\x1b[90m',
+
+    // Background colors
+    bgRed: '\x1b[41m',
+    bgYellow: '\x1b[43m',
+    bgGreen: '\x1b[42m'
+};
+
+// Method-specific configurations
+const methodConfig = {
+    log: {
+        color: colors.reset,
+        symbol: '  ',
+        label: 'INFO'
+    },
+    warn: {
+        color: colors.yellow,
+        symbol: '⚠️ ',
+        label: 'WARN'
+    },
+    error: {
+        color: colors.red,
+        symbol: '✗ ',
+        label: 'ERROR'
+    },
+    table: {
+        color: colors.cyan,
+        symbol: '📊',
+        label: 'DATA'
+    },
+    debug: {
+        color: colors.gray,
+        symbol: '🔍',
+        label: 'DEBUG'
+    },
+    success: {
+        color: colors.green,
+        symbol: '✓ ',
+        label: 'OK'
+    },
+    critical: {
+        color: `${colors.bright}${colors.bgRed}${colors.white}`,
+        symbol: '🔴',
+        label: 'CRITICAL'
+    }
+};
+
+/**
+ * Format timestamp for console output
+ */
+const formatTimestamp = function () {
+    const now = new Date();
+    const time = now.toTimeString().split( ' ' )[ 0 ];  // HH:MM:SS
+    const ms = now.getMilliseconds().toString().padStart( 3, '0' );
+    return `${colors.gray}[${time}.${ms}]${colors.reset}`;
+}; // formatTimestamp()
+
+/**
+ * Format node identifier
+ */
+const formatNodeId = function ( partitionKey ) {
+    const partition = partitionKey ? `/${partitionKey}` : '';
+    return `${colors.cyan}[${partition}]${colors.reset}`;
+}; // formatNodeId()
+
+/**
+ * Format structured data for console
+ */
+const formatData = function ( data, indent = 2 ) {
+    if ( data === null || data === undefined ) {
+        return `${colors.gray}(empty)${colors.reset}`;
+    }
+
+    if ( typeof data === 'string' || typeof data === 'number' || typeof data === 'boolean' ) {
+        return String( data );
+    }
+
+    // For objects, create indented key-value display
+    const spaces = ' '.repeat( indent );
+    const lines = [];
+
+    for ( const [ key, value ] of Object.entries( data ) ) {
+        const formattedKey = `${colors.bright}${key}:${colors.reset}`;
+
+        // Handle different value types
+        let formattedValue;
+        if ( typeof value === 'object' && value !== null ) {
+            // Nested object - use JSON stringify with indent
+            formattedValue = JSON.stringify( value, null, 2 )
+                .split( '\n' )
+                .map( ( line, i ) => ( i === 0 ? line : spaces + line ) )
+                .join( '\n' );
+        } else if ( typeof value === 'string' ) {
+            formattedValue = `"${value}"`;
+        } else {
+            formattedValue = String( value );
+        }
+
+        lines.push( `${spaces}${formattedKey} ${formattedValue}` );
+    }
+
+    return lines.join( '\n' );
+}; // formatData()
+
+/**
+ * Create formatted console output
+ */
+const createConsoleFormatter = function () {
+
+    /**
+     * Format and emit to console
+     *
+     * @param {string} method - Console method (log, warn, error, table)
+     * @param {Object} data - Data to output
+     * @param {string} [partitionKey] - Optional partition identifier
+     * @param {Object} [metadata] - Optional metadata (UNS, etc.)
+     */
+    const format = function ( method, data, partitionKey, metadata ) {
+        const config = methodConfig[ method ] || methodConfig.log;
+
+        // Build header line
+        const timestamp = formatTimestamp();
+        const nodeId = formatNodeId( partitionKey );
+        const header = `${config.symbol} ${timestamp} ${nodeId}`;
+
+        // Handle table method specially
+        if ( method === 'table' && ( Array.isArray( data ) || typeof data === 'object' ) ) {
+            console.log( `${header} ${config.color}[TABLE]${colors.reset}` );
+            console.table( data );
+            return;
+        }
+
+        // Handle critical alerts with emphasis
+        if ( method === 'critical' ) {
+            console.log( `\n${config.color} ${config.label} ${colors.reset}` );
+            console.log( header );
+            console.log( formatData( data, 4 ) );
+            console.log( `${config.color} ${'═'.repeat( 40 )} ${colors.reset}\n` );
+            return;
+        }
+
+        // Standard formatted output
+        const output = [];
+        output.push( header );
+
+        // Add metadata if present (UNS path, etc.)
+        if ( metadata?.uns ) {
+            output.push( `  ${colors.gray}UNS: ${metadata.uns}${colors.reset}` );
+        }
+
+        // Format main data
+        if ( typeof data === 'string' ) {
+            output.push( `  ${config.color}${data}${colors.reset}` );
+        } else {
+            output.push( formatData( data, 2 ) );
+        }
+
+        // Output using appropriate console method
+        const consoleMethod = [ 'log', 'warn', 'error', 'table' ].includes( method ) ? method : 'log';
+
+        console[ consoleMethod ]( output.join( '\n' ) );
+    }; // format()
+
+    /**
+     * Create separator line for visual grouping
+     */
+    const separator = function ( label, char = '═' ) {
+        const line = char.repeat( 40 );
+        if ( label ) {
+            console.log( `${colors.cyan}${line}${colors.reset}` );
+            console.log( `${colors.bright}${colors.cyan}   ${label}${colors.reset}` );
+            console.log( `${colors.cyan}${line}${colors.reset}` );
+        } else {
+            console.log( `${colors.gray}${line}${colors.reset}` );
+        }
+    }; // separator()
+
+    return {
+        format: format,
+        separator: separator,
+        colors: colors  // Export for custom formatting
+    };
+}; // createConsoleFormatter()
+
+export default createConsoleFormatter;

package/src/core/utils/create-smart-store-as/index.js

@@ -0,0 +1,98 @@
+import sanitizeField from './sanitize-field.js';
+import { smartTruncate } from './smart-truncate.js';
+
+/**
+ * Creates a smart, sanitized identifier for storing computed values.
+ * Ensures valid JavaScript identifiers while preserving readability.
+ *
+ * Examples:
+ *   ('ewma', 'temperature') → 'ewma_temperature'
+ *   ('diff', 'temperature', 'setpoint') → 'diff_temperature_setpoint'
+ *   ('mean', 'sensor.pressure') → 'mean_sensor_pressure'
+ *   ('ratio', 'inlet-flow', 'outlet-flow') → 'ratio_inlet_flow_outlet_flow'
+ *
+ * @param {string} statType - Type of computation (e.g., 'diff', 'ewma', 'mean')
+ * @param {string} x - First field name (required)
+ * @param {string} y - Second field name (optional for single-field nodes)
+ * @returns {string} A valid, meaningful identifier under 50 characters
+ */
+const createSmartStoreAs = function ( statType, x, y ) {
+    // Maximum length for the final identifier
+    const MAX_LENGTH = 50;
+
+    // Ensure statType is valid and reasonable length
+    const cleanStatType = ( statType && typeof statType === 'string' && statType.length > 0 ) ?
+        ( statType.length > 10 ? statType.substring( 0, 10 ) : statType ) :
+        'value';
+
+    // Sanitize the primary field
+    const cleanX = sanitizeField( x );
+
+    // Build name based on whether we have one or two fields
+    let fullName;
+    if ( y === null || y === undefined || y === '' ) {
+        // Single field pattern: statType_field
+        fullName = `${cleanStatType}_${cleanX}`;
+    } else {
+        // Two field pattern: statType_field1_field2
+        const cleanY = sanitizeField( y );
+        fullName = `${cleanStatType}_${cleanX}_${cleanY}`;
+    }
+
+    // If it fits within limit, use it as-is
+    if ( fullName.length <= MAX_LENGTH ) {
+        return fullName;
+    }
+
+    // For single field, just truncate it
+    if ( y === null || y === undefined || y === '' ) {
+        const prefixLen = cleanStatType.length + 1;  // statType + 1 underscore
+        const availableLen = MAX_LENGTH - prefixLen - 5;  // Reserve 5 for hash
+
+        if ( availableLen < 5 ) {
+            return smartTruncate( fullName, MAX_LENGTH );
+        }
+
+        const truncatedField = cleanX.length > availableLen ?
+            smartTruncate( cleanX, availableLen ) :
+            cleanX;
+
+        return `${cleanStatType}_${truncatedField}`;
+    }
+
+    // For two fields, sanitize y once and reuse
+    const cleanY = sanitizeField( y );
+
+    // Distribute space between both fields
+    const prefixLen = cleanStatType.length + 2;  // statType + 2 underscores
+    const availableLen = MAX_LENGTH - prefixLen;
+
+    // If even the prefix is too long, truncate everything
+    if ( availableLen < 10 ) {
+        return smartTruncate( fullName, MAX_LENGTH );
+    }
+
+    // Distribute available space between both fields
+    const fieldMaxLen = Math.floor( ( availableLen - 10 ) / 2 );
+
+    // Truncate fields if needed
+    const shortX = cleanX.length > fieldMaxLen ?
+        smartTruncate( cleanX, fieldMaxLen ) :
+        cleanX;
+
+    const shortY = cleanY.length > fieldMaxLen ?
+        smartTruncate( cleanY, fieldMaxLen ) :
+        cleanY;
+
+    // Build shortened name
+    const shortName = `${cleanStatType}_${shortX}_${shortY}`;
+
+    // Final check - if still too long, truncate the whole thing
+    if ( shortName.length > MAX_LENGTH ) {
+        return smartTruncate( shortName, MAX_LENGTH );
+    }
+
+    return shortName;
+}; // createSmartStoreAs()
+
+export default createSmartStoreAs;

package/src/core/utils/create-smart-store-as/sanitize-field.js

@@ -0,0 +1,46 @@
+/**
+ * Sanitizes a field name to create a valid JavaScript identifier part.
+ * Converts common separators to underscores and removes invalid characters.
+ *
+ * @param {string} field - The field name to sanitize
+ * @returns {string} A valid identifier part, 'field' if input is invalid
+ */
+const sanitizeField = function ( field ) {
+    // Handle invalid input
+    if ( !field || typeof field !== 'string' ) {
+        return 'field';
+    }
+
+    // Replace common separators with underscores
+    // This handles dots, hyphens, spaces, and slashes
+    let clean = field.replace( /[\s\-\.\/\\]+/g, '_' );
+
+    // Remove all non-alphanumeric characters except underscores
+    clean = clean.replace( /[^a-zA-Z0-9_]/g, '' );
+
+    // If nothing remains, return default
+    if ( !clean ) {
+        return 'field';
+    }
+
+    // Collapse multiple consecutive underscores into one
+    clean = clean.replace( /_+/g, '_' );
+
+    // Remove leading and trailing underscores
+    clean = clean.replace( /^_+|_+$/g, '' );
+
+    // If nothing remains after trimming underscores, return default
+    if ( !clean ) {
+        return 'field';
+    }
+
+    // Ensure it doesn't start with a number (invalid in JavaScript)
+    // Check AFTER removing leading underscores
+    if ( ( /^\d/ ).test( clean ) ) {
+        clean = '_' + clean;
+    }
+
+    return clean;
+}; // sanitizeField()
+
+export default sanitizeField;

package/src/core/utils/create-smart-store-as/smart-truncate.js

@@ -0,0 +1,93 @@
+/**
+ * Generates a simple hash from a string for uniqueness.
+ * Uses a variant of djb2 algorithm, returns 4-character base36 string.
+ *
+ * @param {string} str - String to hash
+ * @returns {string} 4-character hash
+ */
+const generateHash = function ( str ) {
+    let hash = 5381;
+
+    for ( let i = 0; i < str.length; i += 1 ) {
+        // hash * 33 + char
+        hash = ( ( hash << 5 ) + hash ) + str.charCodeAt( i ); // eslint-disable-line no-bitwise
+        // Convert to 32-bit integer
+        hash &= hash; // eslint-disable-line no-bitwise
+    }
+
+    // Convert to base36 and take last 4 characters
+    return Math.abs( hash ).toString( 36 ).slice( -4 ).padStart( 4, '0' );
+}; // generateHash()
+
+/**
+ * Finds the best truncation point in a string, preferring word boundaries.
+ * Looks for underscores or camelCase transitions.
+ *
+ * @param {string} str - String to analyze
+ * @param {number} maxLen - Maximum length before truncation
+ * @returns {number} Best truncation index
+ */
+const findBestBreakPoint = function ( str, maxLen ) {
+    // For very short strings, just return maxLen
+    if ( maxLen < 10 || str.length <= maxLen ) {
+        return maxLen;
+    }
+
+    const truncated = str.substring( 0, maxLen );
+
+    // Look for the last underscore
+    const lastUnderscore = truncated.lastIndexOf( '_' );
+
+    // Look for the last camelCase boundary (lowercase followed by uppercase)
+    let lastCamelBoundary = -1;
+    for ( let i = truncated.length - 2; i >= 0; i -= 1 ) {
+        if ( ( /[a-z]/ ).test( truncated[i] ) && ( /[A-Z]/ ).test( truncated[i + 1] ) ) {
+            lastCamelBoundary = i + 1;
+            break;
+        }
+    }
+
+    // Choose the better break point
+    const breakPoint = Math.max( lastUnderscore, lastCamelBoundary );
+
+    // Only use the break point if it's not too short (at least 60% of maxLen)
+    if ( breakPoint > maxLen * 0.6 ) {
+        return breakPoint;
+    }
+
+    return maxLen;
+}; // findBestBreakPoint()
+
+/**
+ * Intelligently truncates a string to fit within maxLength.
+ * Tries to break at word boundaries and adds a hash for uniqueness.
+ *
+ * @param {string} str - String to truncate
+ * @param {number} maxLen - Maximum allowed length
+ * @returns {string} Truncated string with hash suffix
+ */
+const smartTruncate = function ( str, maxLen ) {
+    // No truncation needed
+    if ( str.length <= maxLen ) {
+        return str;
+    }
+
+    // Very short maxLen - just truncate directly
+    if ( maxLen < 10 ) {
+        return str.substring( 0, maxLen );
+    }
+
+    // Reserve space for underscore and 4-char hash
+    const availableLen = maxLen - 5;
+
+    // Find best break point
+    const breakPoint = findBestBreakPoint( str, availableLen );
+    const truncated = str.substring( 0, breakPoint );
+
+    // Generate hash from original string for uniqueness
+    const hash = generateHash( str );
+
+    return `${truncated}_${hash}`;
+}; // smartTruncate()
+
+export { smartTruncate, generateHash };

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

@@ -0,0 +1,5 @@
+// Flow build-time utilities. The naming-policy helpers (renderName / template
+// rendering) were retired when fan naming converged on the fixed
+// ${field}_${label} rule shared by the forEach and pick fan constructs.
+export { makeCollisionChecker } from './make-collision-checker.js';
+export { toKebab } from './to-kebab.js';

package/src/core/utils/flow/make-collision-checker.js

@@ -0,0 +1,23 @@
+/**
+ * Collision checker for generated identifiers.
+ * Throws on duplicates; keeps errors explicit and early.
+ */
+
+const makeCollisionChecker = function () {
+    const seen = Object.create( null );
+
+    /**
+     * Assert identifier has not been seen before.
+     * @param {string} id
+     * @param {string=} hint  Optional: human context for error messages
+     */
+    const isDuplicate = function ( id ) {
+        if ( seen[ id ] === 1 ) return true;
+        seen[ id ] = 1;
+        return false;
+    }; // assertUnique()
+
+    return isDuplicate;
+}; // makeCollisionChecker()
+
+export { makeCollisionChecker };

package/src/core/utils/flow/to-kebab.js

@@ -0,0 +1,20 @@
+// core/utils/flow/to-kebab.js
+
+/**
+ * Converts camelCase string to kebab-case.
+ * Used for mapping node module names to directory paths.
+ *
+ * @example
+ * toKebab('esMean') → 'es-mean'
+ * toKebab('pageHinkley') → 'page-hinkley'
+ * toKebab('threshold') → 'threshold'
+ *
+ * @param {string} str - camelCase string
+ * @returns {string} kebab-case string
+ */
+export const toKebab = function ( str ) {
+    return str
+        .replace( /([A-Z])/g, '-$1' )
+        .toLowerCase()
+        .replace( /^-/, '' );
+};

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

@@ -0,0 +1,111 @@
+/**
+ * Half-Life Parameter Utilities
+ *
+ * Converts between half-life (intuitive) and alpha (computational)
+ * parameterizations for exponential decay processes.
+ */
+
+/**
+ * Convert half-life to EWMA alpha parameter.
+ * Uses expm1 for numerical stability with large half-life values.
+ *
+ * @param {number} halfLife  Half-life in consistent units (samples or seconds)
+ * @returns {number} alpha in (0,1)
+ */
+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' );
+    }
+    // alpha = 1 - exp( -ln(2) / halfLife ); use expm1 to avoid cancellation
+    let alpha = -Math.expm1( -( Math.LN2 / halfLife ) );
+
+    // Defensive clamps (never publish 0 or ≥1):
+    const MIN_ALPHA = ( 32 * Number.EPSILON );      // ~3.55e-15 on double
+    const MAX_ALPHA = ( 1 - ( 8 * Number.EPSILON ) );
+    if ( alpha < MIN_ALPHA ) alpha = MIN_ALPHA;
+    if ( alpha > MAX_ALPHA ) alpha = MAX_ALPHA;
+
+    return alpha;
+}; // halfLifeToAlpha()
+
+/**
+ * Convert EWMA alpha to half-life.
+ * Uses log1p for numerical stability with small alpha values.
+ *
+ * @param {number} alpha  Smoothing factor in (0,1)
+ * @returns {number} Half-life in same units used to derive alpha (samples or seconds)
+ */
+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)' );
+    }
+    // halfLife = ln(2) / -ln(1 - alpha) ; use log1p(-alpha) for stability
+    return Math.LN2 / ( -Math.log1p( -alpha ) );
+}; // alphaToHalfLife()
+
+/**
+ * Samples to warm up a slow EWMA so that the initial-condition influence
+ * has decayed to (1 - settledFraction). Half-life is in SAMPLES.
+ *
+ * @param {number} halfLifeSamples  Half-life in samples (> 0)
+ * @param {number} settledFraction  Target fraction absorbed in (0,1), e.g., 0.95
+ * @returns {number} Ceil’d samples to wait
+ */
+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' );
+    }
+    if ( typeof settledFraction !== 'number' || !Number.isFinite( settledFraction ) || ( settledFraction <= 0 ) || ( settledFraction >= 1 ) ) {
+        throw new Error( 'settledFraction must be a finite number in (0,1)' );
+    }
+    // nHL = -log2(1 - settledFraction) = -ln(1 - s)/ln2
+    const nHalfLives = ( -Math.log1p( -settledFraction ) ) / Math.LN2;
+    return Math.ceil( halfLifeSamples * nHalfLives );
+}; // halfLifeToWarmupSamples()
+
+/**
+ * Effective window (samples) for a chosen settled fraction.
+ * By default uses TWO HALF-LIVES → 75% response (settledFraction = 0.75).
+ *
+ * @param {number} halfLifeSamples      Half-life in samples (> 0)
+ * @param {number} settledFraction=0.75 Desired settled fraction (0,1)
+ * @returns {number} Samples corresponding to the chosen settled fraction
+ */
+export const halfLifeToEffectiveWindow = function ( halfLifeSamples, settledFraction = 0.75 ) {
+    return halfLifeToWarmupSamples( halfLifeSamples, settledFraction );
+}; // halfLifeToEffectiveWindow()
+
+/* Notes (samples + half-life only)
+ * Settled fraction s ∈ (0,1):
+ *   nHalfLives = -log1p( -s ) / Math.LN2
+ *
+ * Quick refs (multiply your HLs by these and ceil):
+ *   s=0.75  → 2.000 half-lives
+ *   s=0.865 → 2.885 half-lives   // ≈ 86.5% settled
+ *   s=0.90  → 3.322 half-lives
+ *   s=0.95  → 4.322 half-lives
+ *   s=0.98  → 6.644 half-lives
+ *
+ * Example: HLs = 20, s = 0.95 → ceil( 20 × 4.322 ) = 87 samples.
+ */
+
+/**
+ * Clamp a numeric value between lower and upper bounds.
+ *
+ * Uses a simple ternary chain, which is the fastest pattern in V8
+ * (monomorphic, inlined, no extra function calls). Preferred over
+ * Math.min/Math.max for hot-path use.
+ *
+ * @param {number} x   Value to clamp
+ * @param {number} lo  Lower bound (inclusive)
+ * @param {number} hi  Upper bound (inclusive)
+ * @returns {number}   x constrained to [lo, hi]
+ *
+ * @example
+ * clamp( 5, 0, 10 );     // → 5
+ * clamp( -3, 0, 10 );    // → 0
+ * clamp( 15, 0, 10 );    // → 10
+ */
+export const clamp = function ( x, lo, hi ) {
+    return ( x < lo ) ? lo : ( x > hi ? hi : x );
+}; // clamp()

package/src/core/utils/node/disable.js

@@ -0,0 +1,11 @@
+/**
+ * Disables a node by setting its disable flag to true
+ * @param {Object} state - The node's state object
+ * @returns {boolean} - Always returns true for consistency with control methods
+ */
+const disable = function ( state ) {
+    state.disable = true;
+    return true;
+}; // disable()
+
+export default disable;

package/src/core/utils/node/enable.js

@@ -0,0 +1,11 @@
+/**
+ * Enables a node by setting its disable flag to false
+ * @param {Object} state - The node's state object
+ * @returns {boolean} - Always returns true for consistency with control methods
+ */
+const enable = function ( state ) {
+    state.disable = false;
+    return true;
+}; // enable()
+
+export default enable;

package/src/core/utils/node/execute-triggers.js

@@ -0,0 +1,40 @@
+/**
+ * Execute control triggers with re-entrancy protection.
+ * Called by nodes during their update cycle when trigger conditions are met.
+ *
+ * @param {Object} state - Node state containing resolvedTriggers
+ * @returns {number} Number of triggers executed (0 if skipped or no triggers)
+ */
+const executeTriggers = function ( state ) {
+    // No triggers to execute
+    if ( !state.resolvedTriggers || state.resolvedTriggers.length === 0 ) {
+        return 0;
+    }
+
+    // Prevent re-entrant execution
+    if ( state.inControlPhase ) {
+        // `skippedTriggers` property is being created on demand.
+        state.skippedTriggers = ( state.skippedTriggers || 0 ) + 1;
+        return 0;
+    }
+
+    state.inControlPhase = true;
+    let executed = 0;
+
+    try {
+        const triggers = state.resolvedTriggers;
+        for ( let i = 0; i < triggers.length; i += 1 ) {
+            const { control, targets } = triggers[ i ];
+            for ( let j = 0; j < targets.length; j += 1 ) {
+                control( targets[ j ] );
+                executed += 1;
+            }
+        }
+    } finally {
+        state.inControlPhase = false;
+    }
+
+    return executed;
+};
+
+export default executeTriggers;

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

@@ -0,0 +1,10 @@
+export { default as executeTriggers } from './execute-triggers.js';
+export { default as validateSpec } from './validate-spec.js';
+export { default as publishNaN } from './publish-nan.js';
+export { default as enable } from './enable.js';
+export { default as disable } from './disable.js';
+export { default as pause } from './pause.js';
+export { default as unpause } from './unpause.js';
+export { default as populatePredicateInput } from './populate-predicate-inputs.js';
+export { default as resetPredicateInput } from './reset-predicate-inputs.js';
+