@hotmeshio/hotmesh 0.0.56 → 0.0.58

package/build/services/engine/index.js

@@ -96,6 +96,7 @@ 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;
@@ -133,6 +134,7 @@ 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)];
@@ -158,11 +160,13 @@ 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));
@@ -177,6 +181,7 @@ 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);
@@ -185,6 +190,7 @@ 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);
@@ -209,6 +215,7 @@ class EngineService {
             sparse: query.sparse,
         };
     }
+    // ****************** STREAM RE-ENTRY POINT *****************
     async processStreamMessage(streamData) {
         this.logger.debug('engine-process-stream-message', {
             jid: streamData.metadata.jid,
@@ -230,18 +237,22 @@ 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) {
-            const activityHandler = await this.initActivity(`.${streamData.metadata.aid}`, context.data, context);
+            //TRANSITION (ADJACENT ACTIVITY)
+            const activityHandler = await this.initActivity(`.${streamData.metadata.aid}`, context.data, context); //todo: `as Activity` (type is more generic)
             await activityHandler.process();
         }
         else if (streamData.type === stream_1.StreamDataType.AWAIT) {
+            //TRIGGER JOB
             context.metadata = {
                 ...context.metadata,
                 pj: streamData.metadata.jid,
@@ -256,10 +267,12 @@ 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');
         }
@@ -269,8 +282,10 @@ 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 = {
@@ -314,8 +329,11 @@ 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,
@@ -323,9 +341,12 @@ 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}`);
@@ -385,6 +406,8 @@ 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) {
@@ -394,24 +417,29 @@ 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: {
@@ -435,6 +463,7 @@ class EngineService {
                 }
             });
             setTimeout(() => {
+                //note: job is still active (the subscriber timed out)
                 this.delistJobCallback(jobId);
                 reject({
                     code: enums_1.HMSH_CODE_TIMEOUT,
@@ -445,6 +474,7 @@ 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',
@@ -483,7 +513,9 @@ 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);
@@ -499,9 +531,15 @@ 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);
     }
@@ -512,11 +550,15 @@ 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,15 +3,42 @@ 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,12 +4,21 @@ 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();
@@ -20,10 +29,22 @@ 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: {
@@ -37,6 +58,7 @@ 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, '/')}`;
@@ -44,6 +66,7 @@ class ExporterService {
                 process[`${dimensions}/${path}`] = resolved;
             }
             else if (key.length === 3) {
+                //job state
                 process[this.inflateKey(key)] = serializer_1.SerializerService.fromString(value);
             }
         });
@@ -53,6 +76,13 @@ 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+)$/;
@@ -64,6 +94,7 @@ class ExporterService {
             let type;
             let dimensionKey = '';
             if (match) {
+                //hook-originating dependency
                 const [_, dimension, counter] = match;
                 dimensionKey = dimension.split(',').join('/');
                 prefix = `${dimensionKey}[${counter}]`;
@@ -72,11 +103,13 @@ 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.js

@@ -67,6 +67,7 @@ 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);
     }
@@ -88,6 +89,7 @@ class HotMeshService {
     async add(streamData) {
         return await this.engine.add(streamData);
     }
+    // ************* QUORUM METHODS *************
     async rollCall(delay) {
         return await this.quorum?.rollCall(delay);
     }
@@ -104,6 +106,7 @@ class HotMeshService {
         }
         return await this.quorum?.pub(throttleMessage);
     }
+    // ************* COMPILER METHODS *************
     async plan(path) {
         return await this.engine?.plan(path);
     }
@@ -111,8 +114,10 @@ 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);
     }
@@ -137,12 +142,15 @@ 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,12 +15,14 @@ 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,8 +7,22 @@ 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,14 +27,28 @@ 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,5 +1,12 @@
 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,6 +3,13 @@ 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,6 +3,7 @@ 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);
@@ -37,6 +38,7 @@ 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,7 +13,22 @@ 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,10 +30,14 @@ 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]);
+            resolved = this.processCells(this.rules[0]); // Add type assertion
             index = 1;
         }
         const len = this.rules.length;
@@ -43,6 +47,17 @@ 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])) {
@@ -63,25 +78,30 @@ 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;
+                const [functionName, ...params] = currentRow; // Add type assertion
+                //use resolved values from prior row (n - 1) as input params to cell 1 function
                 let resolvedValue;
                 if (this.isContextVariable(functionName)) {
                     resolvedValue = this.resolveContextValue(functionName);
@@ -89,6 +109,7 @@ 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,6 +28,10 @@ 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;
@@ -35,6 +39,9 @@ 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 };