@hotmeshio/hotmesh 0.0.55 → 0.0.56

package/build/services/engine/index.js

@@ -96,7 +96,6 @@ class EngineService {
         if (this.cacheMode === 'nocache') {
             const app = await this.store.getApp(this.appId, true);
             if (app.version.toString() === this.untilVersion.toString()) {
-                //new version is deployed; OK to cache again
                 if (!this.apps)
                     this.apps = {};
                 this.apps[this.appId] = app;
@@ -134,7 +133,6 @@ class EngineService {
     async throttle(delayInMillis) {
         this.router.setThrottle(delayInMillis);
     }
-    // ************* METADATA/MODEL METHODS *************
     async initActivity(topic, data = {}, context) {
         const [activityId, schema] = await this.getSchema(topic);
         const ActivityHandler = activities_1.default[utils_1.polyfill.resolveActivityType(schema.type)];
@@ -160,13 +158,11 @@ class EngineService {
             throw new Error(`no app found for id ${this.appId}`);
         }
         if (this.isPrivate(topic)) {
-            //private subscriptions use the schema id (.activityId)
             const activityId = topic.substring(1);
             const schema = await this.store.getSchema(activityId, await this.getVID(app));
             return [activityId, schema];
         }
         else {
-            //public subscriptions use a topic (a.b.c) that is associated with a schema id
             const activityId = await this.store.getSubscription(topic, await this.getVID(app));
             if (activityId) {
                 const schema = await this.store.getSchema(activityId, await this.getVID(app));
@@ -181,7 +177,6 @@ class EngineService {
     isPrivate(topic) {
         return topic.startsWith('.');
     }
-    // ************* COMPILER METHODS *************
     async plan(pathOrYAML) {
         const compiler = new compiler_1.CompilerService(this.store, this.logger);
         return await compiler.plan(pathOrYAML);
@@ -190,7 +185,6 @@ class EngineService {
         const compiler = new compiler_1.CompilerService(this.store, this.logger);
         return await compiler.deploy(pathOrYAML);
     }
-    // ************* REPORTER METHODS *************
     async getStats(topic, query) {
         const { id, version } = await this.getVID();
         const reporter = new reporter_1.ReporterService({ id, version }, this.store, this.logger);
@@ -215,7 +209,6 @@ class EngineService {
             sparse: query.sparse,
         };
     }
-    // ****************** STREAM RE-ENTRY POINT *****************
     async processStreamMessage(streamData) {
         this.logger.debug('engine-process-stream-message', {
             jid: streamData.metadata.jid,
@@ -237,22 +230,18 @@ class EngineService {
             data: streamData.data,
         };
         if (streamData.type === stream_1.StreamDataType.TIMEHOOK) {
-            //TIMEHOOK AWAKEN
             const activityHandler = await this.initActivity(`.${streamData.metadata.aid}`, context.data, context);
             await activityHandler.processTimeHookEvent(streamData.metadata.jid);
         }
         else if (streamData.type === stream_1.StreamDataType.WEBHOOK) {
-            //WEBHOOK AWAKEN (SIGNAL IN)
             const activityHandler = await this.initActivity(`.${streamData.metadata.aid}`, context.data, context);
             await activityHandler.processWebHookEvent(streamData.status, streamData.code);
         }
         else if (streamData.type === stream_1.StreamDataType.TRANSITION) {
-            //TRANSITION (ADJACENT ACTIVITY)
-            const activityHandler = await this.initActivity(`.${streamData.metadata.aid}`, context.data, context); //todo: `as Activity` (type is more generic)
+            const activityHandler = await this.initActivity(`.${streamData.metadata.aid}`, context.data, context);
             await activityHandler.process();
         }
         else if (streamData.type === stream_1.StreamDataType.AWAIT) {
-            //TRIGGER JOB
             context.metadata = {
                 ...context.metadata,
                 pj: streamData.metadata.jid,
@@ -267,12 +256,10 @@ class EngineService {
             await activityHandler.process();
         }
         else if (streamData.type === stream_1.StreamDataType.RESULT) {
-            //AWAIT RESULT
             const activityHandler = await this.initActivity(`.${context.metadata.aid}`, streamData.data, context);
             await activityHandler.processEvent(streamData.status, streamData.code);
         }
         else {
-            //WORKER RESULT
             const activityHandler = await this.initActivity(`.${streamData.metadata.aid}`, streamData.data, context);
             await activityHandler.processEvent(streamData.status, streamData.code, 'output');
         }
@@ -282,10 +269,8 @@ class EngineService {
             aid: streamData.metadata.aid
         });
     }
-    // ***************** `AWAIT` ACTIVITY RETURN RESPONSE ****************
     async execAdjacentParent(context, jobOutput, emit = false) {
         if (this.hasParentJob(context)) {
-            //errors are stringified `StreamError` objects
             const error = this.resolveError(jobOutput.metadata);
             const spn = context['$self']?.output?.metadata?.l2s || context['$self']?.output?.metadata?.l1s;
             const streamData = {
@@ -329,11 +314,8 @@ class EngineService {
             return JSON.parse(metadata.err);
         }
     }
-    // ****************** `INTERRUPT` ACTIVE JOBS *****************
     async interrupt(topic, jobId, options = {}) {
-        //immediately interrupt the job, going directly to the data source
         await this.store.interrupt(topic, jobId, options);
-        //now that the job is interrupted, we can clean up
         const context = await this.getState(topic, jobId);
         const completionOpts = {
             interrupt: options.descend,
@@ -341,12 +323,9 @@ class EngineService {
         };
         return await this.runJobCompletionTasks(context, completionOpts);
     }
-    // ****************** `SCRUB` CLEAN COMPLETED JOBS *****************
     async scrub(jobId) {
-        //todo: do not allow scrubbing of non-existent or actively running job
         await this.store.scrub(jobId);
     }
-    // ****************** `HOOK` ACTIVITY RE-ENTRY POINT *****************
     async hook(topic, data, status = stream_1.StreamStatus.SUCCESS, code = 200) {
         const hookRule = await this.taskService.getHookRule(topic);
         const [aid] = await this.getSchema(`.${hookRule.to}`);
@@ -406,8 +385,6 @@ class EngineService {
             throw new Error(`unable to find hook rule for topic ${hookTopic}`);
         }
     }
-    // ********************** PUB/SUB ENTRY POINT **********************
-    //publish (returns just the job id)
     async pub(topic, data, context, extended) {
         const activityHandler = await this.initActivity(topic, data, context);
         if (activityHandler) {
@@ -417,29 +394,24 @@ class EngineService {
             throw new Error(`unable to process activity for topic ${topic}`);
         }
     }
-    //subscribe to all jobs for a topic
     async sub(topic, callback) {
         const subscriptionCallback = async (topic, message) => {
             callback(message.topic, message.job);
         };
         return await this.subscribe.subscribe(key_1.KeyType.QUORUM, subscriptionCallback, this.appId, topic);
     }
-    //unsubscribe to all jobs for a topic
     async unsub(topic) {
         return await this.subscribe.unsubscribe(key_1.KeyType.QUORUM, this.appId, topic);
     }
-    //subscribe to all jobs for a wildcard topic
     async psub(wild, callback) {
         const subscriptionCallback = async (topic, message) => {
             callback(message.topic, message.job);
         };
         return await this.subscribe.psubscribe(key_1.KeyType.QUORUM, subscriptionCallback, this.appId, wild);
     }
-    //unsubscribe to all jobs for a wildcard topic
     async punsub(wild) {
         return await this.subscribe.punsubscribe(key_1.KeyType.QUORUM, this.appId, wild);
     }
-    //publish and await (returns the job and data (if ready)); throws error with jobid if not
     async pubsub(topic, data, context, timeout = enums_1.HMSH_OTT_WAIT_TIME) {
         context = {
             metadata: {
@@ -463,7 +435,6 @@ class EngineService {
                 }
             });
             setTimeout(() => {
-                //note: job is still active (the subscriber timed out)
                 this.delistJobCallback(jobId);
                 reject({
                     code: enums_1.HMSH_CODE_TIMEOUT,
@@ -474,7 +445,6 @@ class EngineService {
         });
     }
     async pubOneTimeSubs(context, jobOutput, emit = false) {
-        //todo: subscriber should query for the job...only publish minimum context needed
         if (this.hasOneTimeSubscription(context)) {
             const message = {
                 type: 'job',
@@ -513,9 +483,7 @@ class EngineService {
     hasOneTimeSubscription(context) {
         return Boolean(context.metadata.ngn);
     }
-    // ********** JOB COMPLETION/CLEANUP (AND JOB EMIT) ***********
     async runJobCompletionTasks(context, options = {}) {
-        //'emit' indicates the job is still active
         const isAwait = this.hasParentJob(context, true);
         const isOneTimeSub = this.hasOneTimeSubscription(context);
         const topic = await this.getPublishesTopic(context);
@@ -531,15 +499,9 @@ class EngineService {
         }
         return msgId;
     }
-    /**
-     * Job hash expiration is typically reliant on the metadata field
-     * if the activity concludes normally. However, if the job is `interrupted`,
-     * it will be expired immediately.
-     */
     resolveExpires(context, options) {
         return options.expire ?? context.metadata.expire ?? enums_1.HMSH_EXPIRE_JOB_SECONDS;
     }
-    // ****** GET JOB STATE/COLLATION STATUS BY ID *********
     async export(jobId) {
         return await this.exporter.export(jobId);
     }
@@ -550,15 +512,11 @@ class EngineService {
         const { id: appId } = await this.getVID();
         return await this.store.getStatus(jobId, appId);
     }
-    //todo: add 'options' parameter;
-    //      (e.g, if {dimensions:true}, use hscan to deliver
-    //      the full set of dimensional job data)
     async getState(topic, jobId) {
         const jobSymbols = await this.store.getSymbols(`$${topic}`);
         const consumes = {
             [`$${topic}`]: Object.keys(jobSymbols)
         };
-        //job data exists at the 'zero' dimension; pass an empty object
         const dIds = {};
         const output = await this.store.getState(jobId, consumes, dIds);
         if (!output) {

package/build/services/exporter/index.d.ts

@@ -3,42 +3,15 @@ import { StoreService } from '../store';
 import { DependencyExport, ExportOptions, JobActionExport, JobExport } from '../../types/exporter';
 import { RedisClient, RedisMulti } from '../../types/redis';
 import { StringStringType, Symbols } from "../../types/serializer";
-/**
- * Downloads job data from Redis (hscan, hmget, hgetall)
- * Expands process data and includes dependency list
- */
 declare class ExporterService {
     appId: string;
     logger: ILogger;
     store: StoreService<RedisClient, RedisMulti>;
     symbols: Promise<Symbols> | Symbols;
     constructor(appId: string, store: StoreService<RedisClient, RedisMulti>, logger: ILogger);
-    /**
-     * Convert the job hash and dependency list into a JobExport object.
-     * This object contains various facets that describe the interaction
-     * in terms relevant to narrative storytelling.
-     */
     export(jobId: string, options?: ExportOptions): Promise<JobExport>;
-    /**
-     * Inflates the key from Redis, 3-character symbol
-     * into a human-readable JSON path, reflecting the
-     * tree-like structure of the unidimensional Hash
-     */
     inflateKey(key: string): string;
-    /**
-     * Inflates the job data from Redis into a JobExport object
-     * @param jobHash - the job data from Redis
-     * @param dependencyList - the list of dependencies for the job
-     * @returns - the inflated job data
-     */
     inflate(jobHash: StringStringType, dependencyList: string[]): JobExport;
-    /**
-     * Inflates the dependency data from Redis into a JobExport object by
-     * organizing the dimensional isolate in sch a way asto interleave
-     * into a story
-     * @param data - the dependency data from Redis
-     * @returns - the organized dependency data
-     */
     inflateDependencyData(data: string[], actions: JobActionExport): DependencyExport[];
 }
 export { ExporterService };

package/build/services/exporter/index.js

@@ -4,21 +4,12 @@ exports.ExporterService = void 0;
 const key_1 = require("../../modules/key");
 const utils_1 = require("../../modules/utils");
 const serializer_1 = require("../serializer");
-/**
- * Downloads job data from Redis (hscan, hmget, hgetall)
- * Expands process data and includes dependency list
- */
 class ExporterService {
     constructor(appId, store, logger) {
         this.appId = appId;
         this.logger = logger;
         this.store = store;
     }
-    /**
-     * Convert the job hash and dependency list into a JobExport object.
-     * This object contains various facets that describe the interaction
-     * in terms relevant to narrative storytelling.
-     */
     async export(jobId, options = {}) {
         if (!this.symbols) {
             this.symbols = this.store.getAllSymbols();
@@ -29,22 +20,10 @@ class ExporterService {
         const jobExport = this.inflate(jobData, depData);
         return jobExport;
     }
-    /**
-     * Inflates the key from Redis, 3-character symbol
-     * into a human-readable JSON path, reflecting the
-     * tree-like structure of the unidimensional Hash
-     */
     inflateKey(key) {
         return (key in this.symbols) ? this.symbols[key] : key;
     }
-    /**
-     * Inflates the job data from Redis into a JobExport object
-     * @param jobHash - the job data from Redis
-     * @param dependencyList - the list of dependencies for the job
-     * @returns - the inflated job data
-     */
     inflate(jobHash, dependencyList) {
-        //the list of actions taken in the workflow and hook functions
         const actions = {
             hooks: {},
             main: {
@@ -58,7 +37,6 @@ class ExporterService {
         Object.entries(jobHash).forEach(([key, value]) => {
             const match = key.match(regex);
             if (match) {
-                //activity process state
                 const [_, letters, numbers] = match;
                 const path = this.inflateKey(letters);
                 const dimensions = `${numbers.replace(/,/g, '/')}`;
@@ -66,7 +44,6 @@ class ExporterService {
                 process[`${dimensions}/${path}`] = resolved;
             }
             else if (key.length === 3) {
-                //job state
                 process[this.inflateKey(key)] = serializer_1.SerializerService.fromString(value);
             }
         });
@@ -76,13 +53,6 @@ class ExporterService {
             status: jobHash[':'],
         };
     }
-    /**
-     * Inflates the dependency data from Redis into a JobExport object by
-     * organizing the dimensional isolate in sch a way asto interleave
-     * into a story
-     * @param data - the dependency data from Redis
-     * @returns - the organized dependency data
-     */
     inflateDependencyData(data, actions) {
         const hookReg = /([0-9,]+)-(\d+)$/;
         const flowReg = /-(\d+)$/;
@@ -94,7 +64,6 @@ class ExporterService {
             let type;
             let dimensionKey = '';
             if (match) {
-                //hook-originating dependency
                 const [_, dimension, counter] = match;
                 dimensionKey = dimension.split(',').join('/');
                 prefix = `${dimensionKey}[${counter}]`;
@@ -103,13 +72,11 @@ class ExporterService {
             else {
                 const match = jobId.match(flowReg);
                 if (match) {
-                    //main workflow-originating dependency
                     const [_, counter] = match;
                     prefix = `[${counter}]`;
                     type = 'flow';
                 }
                 else {
-                    //'other' types like signal cleanup
                     prefix = '/';
                     type = 'other';
                 }

package/build/services/hotmesh/index.d.ts

@@ -4,11 +4,11 @@ import { QuorumService } from '../quorum';
 import { WorkerService } from '../worker';
 import { JobState, JobData, JobOutput, JobStatus, JobInterruptOptions, ExtensionType } from '../../types/job';
 import { HotMeshConfig, HotMeshManifest } from '../../types/hotmesh';
+import { JobExport } from '../../types/exporter';
 import { JobMessageCallback, QuorumProfile, ThrottleOptions } from '../../types/quorum';
+import { StringAnyType, StringStringType } from '../../types/serializer';
 import { JobStatsInput, GetStatsOptions, IdsResponse, StatsResponse } from '../../types/stats';
 import { StreamCode, StreamData, StreamDataResponse, StreamStatus } from '../../types/stream';
-import { StringAnyType, StringStringType } from '../../types/serializer';
-import { JobExport } from '../../types/exporter';
 declare class HotMeshService {
     namespace: string;
     appId: string;

package/build/services/hotmesh/index.js

@@ -5,12 +5,12 @@ const key_1 = require("../../modules/key");
 const utils_1 = require("../../modules/utils");
 const redis_1 = require("../connector/clients/redis");
 const ioredis_1 = require("../connector/clients/ioredis");
+const connector_1 = require("../connector");
 const engine_1 = require("../engine");
 const logger_1 = require("../logger");
 const quorum_1 = require("../quorum");
 const router_1 = require("../router");
 const worker_1 = require("../worker");
-const connector_1 = require("../connector");
 class HotMeshService {
     constructor() {
         this.engine = null;
@@ -67,7 +67,6 @@ class HotMeshService {
     async doWork(config, logger) {
         this.workers = await worker_1.WorkerService.init(this.namespace, this.appId, this.guid, config, logger);
     }
-    // ************* PUB/SUB METHODS *************
     async pub(topic, data = {}, context, extended) {
         return await this.engine?.pub(topic, data, context, extended);
     }
@@ -89,7 +88,6 @@ class HotMeshService {
     async add(streamData) {
         return await this.engine.add(streamData);
     }
-    // ************* QUORUM METHODS *************
     async rollCall(delay) {
         return await this.quorum?.rollCall(delay);
     }
@@ -106,7 +104,6 @@ class HotMeshService {
         }
         return await this.quorum?.pub(throttleMessage);
     }
-    // ************* COMPILER METHODS *************
     async plan(path) {
         return await this.engine?.plan(path);
     }
@@ -114,10 +111,8 @@ class HotMeshService {
         return await this.engine?.deploy(pathOrYAML);
     }
     async activate(version, delay) {
-        //activation is a quorum operation
         return await this.quorum?.activate(version, delay);
     }
-    // ************* REPORTER METHODS *************
     async export(jobId) {
         return await this.engine?.export(jobId);
     }
@@ -142,15 +137,12 @@ class HotMeshService {
     async resolveQuery(topic, query) {
         return await this.engine?.resolveQuery(topic, query);
     }
-    // ****************** `INTERRUPT` ACTIVE JOBS *****************
     async interrupt(topic, jobId, options = {}) {
         return await this.engine?.interrupt(topic, jobId, options);
     }
-    // ****************** `SCRUB` CLEAN COMPLETED JOBS *****************
     async scrub(jobId) {
         await this.engine?.scrub(jobId);
     }
-    // ****** `HOOK` ACTIVITY RE-ENTRY POINT ******
     async hook(topic, data, status, code) {
         return await this.engine?.hook(topic, data, status, code);
     }

package/build/services/logger/index.js

@@ -15,14 +15,12 @@ class LoggerService {
             level: this.logLevel,
             format: winston_1.format.combine(winston_1.format.colorize(), winston_1.format.timestamp(), winston_1.format.printf((info) => {
                 const { timestamp, level, message } = info;
-                // Extract the object from the `info` object's `Symbol(splat)` field
                 const symbols = Object.getOwnPropertySymbols(info);
                 const splatSymbol = symbols.find(symbol => symbol.toString() === 'Symbol(splat)');
                 let splatData = {};
                 if (splatSymbol) {
                     splatData = info[splatSymbol][0] || {};
                 }
-                // Pass it to the `tagify` method
                 const tags = this.tagify(splatData);
                 return `${timestamp} [${level}] [${this.name || this.appId}:${this.instanceId}] ${message} ${tags}`;
             })),

package/build/services/mapper/index.d.ts

@@ -7,22 +7,8 @@ declare class MapperService {
     constructor(rules: Record<string, unknown>, data: JobState);
     mapRules(): Record<string, unknown>;
     private traverseRules;
-    /**
-     * resolves a pipe expression of the form: { @pipe: [["{data.foo.bar}", 2, false, "hello world"]] }
-     * @param value
-     * @returns
-     */
     private pipe;
-    /**
-     * resolves a mapping expression in the form: "{data.foo.bar}" or 2 or false or "hello world"
-     * @param value
-     * @returns
-     */
     private resolve;
-    /**
-     * Evaluates a transition rule against the current job state and incoming Stream message
-     * to determine which (if any) transition should be taken.
-     */
     static evaluate(transitionRule: TransitionRule | boolean, context: JobState, code: StreamCode): boolean;
 }
 export { MapperService };

package/build/services/mapper/index.js

@@ -27,28 +27,14 @@ class MapperService {
             return this.resolve(rules);
         }
     }
-    /**
-     * resolves a pipe expression of the form: { @pipe: [["{data.foo.bar}", 2, false, "hello world"]] }
-     * @param value
-     * @returns
-     */
     pipe(value) {
         const pipe = new pipe_1.Pipe(value, this.data);
         return pipe.process();
     }
-    /**
-     * resolves a mapping expression in the form: "{data.foo.bar}" or 2 or false or "hello world"
-     * @param value
-     * @returns
-     */
     resolve(value) {
         const pipe = new pipe_1.Pipe([[value]], this.data);
         return pipe.process();
     }
-    /**
-     * Evaluates a transition rule against the current job state and incoming Stream message
-     * to determine which (if any) transition should be taken.
-     */
     static evaluate(transitionRule, context, code) {
         if (typeof transitionRule === 'boolean') {
             return transitionRule;

package/build/services/pipe/functions/date.d.ts

@@ -1,12 +1,5 @@
 type DateInput = Date | string | number;
 declare class DateHandler {
-    /**
-     * It is so common in mapping operations to use a string (ISO) date as input. This helper
-     * method allows for a more-concise mapping ruleset by avoiding date initialization boilerplate
-     * code and instead handles the ISO, Milliseconds, and ECMAScript Date input types.
-     * @param input
-     * @returns
-     */
     static getDateInstance(input: DateInput): Date;
     fromISOString(isoString: string): Date;
     now(): number;

package/build/services/pipe/functions/date.js

@@ -3,13 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DateHandler = void 0;
 const utils_1 = require("../../../modules/utils");
 class DateHandler {
-    /**
-     * It is so common in mapping operations to use a string (ISO) date as input. This helper
-     * method allows for a more-concise mapping ruleset by avoiding date initialization boilerplate
-     * code and instead handles the ISO, Milliseconds, and ECMAScript Date input types.
-     * @param input
-     * @returns
-     */
     static getDateInstance(input) {
         const ISO_REGEX = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z)?$/;
         if (typeof input === 'string') {

package/build/services/pipe/functions/math.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MathHandler = void 0;
 class MathHandler {
     add(...operands) {
-        // @ts-ignore
         return operands.reduce((a, b) => {
             if (Array.isArray(b)) {
                 return a + this.add(...b);
@@ -38,7 +37,6 @@ class MathHandler {
         if (operands.length === 0) {
             throw new Error('At least one operand is required.');
         }
-        // @ts-ignore
         return operands.reduce((a, b) => {
             if (Array.isArray(b)) {
                 return a * this.multiply(...b);

package/build/services/pipe/index.d.ts

@@ -13,22 +13,7 @@ declare class Pipe {
     static resolve(unresolved: {
         [key: string]: unknown;
     } | PipeItem, context: Partial<JobState>): any;
-    /**
-     * loop through each PipeItem row in this Pipe, resolving and transforming line by line
-     * @returns {any} the result of the pipe
-     */
     process(resolved?: unknown[] | null): any;
-    /**
-     * Transforms iterable `input` into a single value. Vars $output, $item, $key
-     * and $input are available. The final statement in the iterator (the reduction)
-     * is assumed to be the return value. A default $output object may be provided
-     * to the iterator by placing the the second cell of the preceding row. Otherwise,
-     * construct the object during first run and ensure it is the first cell of the
-     * last row of the iterator, so it is returned as the $output for the next cycle
-     * @param {unknown[]} input
-     * @returns {unknown}
-     * @private
-     */
     reduce(input: Array<unknown[]>): unknown;
     private processRow;
     static resolveFunction(functionName: string): any;

package/build/services/pipe/index.js

@@ -30,14 +30,10 @@ class Pipe {
         }
         return pipe.process();
     }
-    /**
-     * loop through each PipeItem row in this Pipe, resolving and transforming line by line
-     * @returns {any} the result of the pipe
-     */
     process(resolved = null) {
         let index = 0;
         if (!(resolved || this.isPipeType(this.rules[0]) || this.isreduceType(this.rules[0]))) {
-            resolved = this.processCells(this.rules[0]); // Add type assertion
+            resolved = this.processCells(this.rules[0]);
             index = 1;
         }
         const len = this.rules.length;
@@ -47,17 +43,6 @@ class Pipe {
         }
         return resolved[0];
     }
-    /**
-     * Transforms iterable `input` into a single value. Vars $output, $item, $key
-     * and $input are available. The final statement in the iterator (the reduction)
-     * is assumed to be the return value. A default $output object may be provided
-     * to the iterator by placing the the second cell of the preceding row. Otherwise,
-     * construct the object during first run and ensure it is the first cell of the
-     * last row of the iterator, so it is returned as the $output for the next cycle
-     * @param {unknown[]} input
-     * @returns {unknown}
-     * @private
-     */
     reduce(input) {
         let resolved = input[1] ?? null;
         if (Array.isArray(input[0])) {
@@ -78,30 +63,25 @@ class Pipe {
     }
     processRow(currentRow, resolvedPriorRow, subPipeQueue) {
         if (resolvedPriorRow && this.isreduceType(currentRow)) {
-            //reduce the resolvedPriorRow and return the output from the reducer
             const subPipe = new Pipe(currentRow['@reduce'], this.jobData);
             const reduced = subPipe.reduce(resolvedPriorRow);
             return reduced;
         }
         else if (this.isPipeType(currentRow)) {
-            //process subPipe and push to subPipeQueue; echo resolvedPriorRow
             const subPipe = new Pipe(currentRow['@pipe'], this.jobData, this.context);
             subPipeQueue.push(subPipe.process());
             return resolvedPriorRow;
         }
         else {
-            //pivot the subPipeQueue into the arguments array (resolvedPriorRow)
             if (subPipeQueue.length > 0) {
                 resolvedPriorRow = [...subPipeQueue];
                 subPipeQueue.length = 0;
             }
             if (!resolvedPriorRow) {
-                //if no prior row, use current row as prior row
                 return [].concat(this.processCells(Array.isArray(currentRow) ? [...currentRow] : []));
             }
             else {
-                const [functionName, ...params] = currentRow; // Add type assertion
-                //use resolved values from prior row (n - 1) as input params to cell 1 function
+                const [functionName, ...params] = currentRow;
                 let resolvedValue;
                 if (this.isContextVariable(functionName)) {
                     resolvedValue = this.resolveContextValue(functionName);
@@ -109,7 +89,6 @@ class Pipe {
                 else {
                     resolvedValue = Pipe.resolveFunction(functionName)(...resolvedPriorRow);
                 }
-                //resolve remaining cells in row and return concatenated with resolvedValue
                 return [resolvedValue].concat(this.processCells([...params]));
             }
         }

package/build/services/quorum/index.d.ts

@@ -28,10 +28,6 @@ declare class QuorumService {
     subscriptionHandler(): SubscriptionCallback;
     sayPong(appId: string, guid: string, originator: string, details?: boolean): Promise<void>;
     requestQuorum(delay?: number, details?: boolean): Promise<number>;
-    /**
-     * A quorum-wide command to broadcaset system details.
-     *
-     */
     doRollCall(message: RollCallMessage): Promise<void>;
     cancelRollCall(): void;
     stop(): void;
@@ -39,9 +35,6 @@ declare class QuorumService {
     sub(callback: QuorumMessageCallback): Promise<void>;
     unsub(callback: QuorumMessageCallback): Promise<void>;
     rollCall(delay?: number): Promise<QuorumProfile[]>;
-    /**
-     * request a quorum; if successful activate the app version
-     */
     activate(version: string, delay?: number, count?: number): Promise<boolean>;
 }
 export { QuorumService };