fable 3.1.62 → 3.1.64

package/docs/services/expression-parser.md

@@ -264,6 +264,65 @@ parser.solve('Result = MONTECARLO SAMPLECOUNT 5000 VAR x PT x -3 PT x 3 VAR y PT
     {}, {}, manifest, dest);
 ```
 
+### MULTIROWMAP Expressions
+
+Iterate over an array of objects (rows) with multi-row lookback and lookahead. Each variable can reference the current row or any row at a relative offset, with configurable defaults for out-of-bounds access.
+
+```javascript
+// Syntax:
+// Result = MULTIROWMAP ROWS FROM <address>
+//   [SERIESSTART <n>] [SERIESSTEP <n>]
+//   VAR <name> FROM <property> [OFFSET <n>] [DEFAULT <value>]
+//   ... : <expression>
+
+// Basic: compute area from each row's Width and Height
+parser.solve('Areas = MULTIROWMAP ROWS FROM Rows VAR w FROM Width VAR h FROM Height : w * h',
+    { Rows: [{Width:10,Height:20}, {Width:30,Height:40}] }, {}, manifest, dest);
+// dest.Areas === ['200', '1200']
+
+// Previous row lookback (day-over-day change)
+parser.solve('Change = MULTIROWMAP ROWS FROM Prices VAR Today FROM Close VAR Yesterday FROM Close OFFSET -1 DEFAULT 0 : Today - Yesterday',
+    data, {}, manifest, dest);
+
+// Two-row lookback (Fibonacci verification)
+parser.solve('Check = MULTIROWMAP ROWS FROM FibRows VAR Cur FROM Fib VAR P1 FROM Fib OFFSET -1 DEFAULT 0 VAR P2 FROM Fib OFFSET -2 DEFAULT 0 : Cur - (P1 + P2)',
+    data, {}, manifest, dest);
+
+// Forward lookback (next row reference)
+parser.solve('NextDiff = MULTIROWMAP ROWS FROM Rows VAR Cur FROM Value VAR Next FROM Value OFFSET 1 DEFAULT 0 : Next - Cur',
+    data, {}, manifest, dest);
+
+// Central difference (both directions)
+parser.solve('Deriv = MULTIROWMAP ROWS FROM Rows VAR Prev FROM Value OFFSET -1 DEFAULT 0 VAR Next FROM Value OFFSET 1 DEFAULT 0 : (Next - Prev) / 2',
+    data, {}, manifest, dest);
+
+// SERIESSTART: skip initial rows (start from row 2)
+parser.solve('MA = MULTIROWMAP ROWS FROM Prices SERIESSTART 2 VAR c0 FROM Close VAR c1 FROM Close OFFSET -1 DEFAULT 0 VAR c2 FROM Close OFFSET -2 DEFAULT 0 : (c0 + c1 + c2) / 3',
+    data, {}, manifest, dest);
+
+// Negative SERIESSTART: start from 2 rows before end
+parser.solve('LastTwo = MULTIROWMAP ROWS FROM Rows SERIESSTART -2 VAR v FROM Value : v + 0',
+    data, {}, manifest, dest);
+
+// SERIESSTEP -1: iterate backwards
+parser.solve('Reversed = MULTIROWMAP ROWS FROM Rows SERIESSTART -1 SERIESSTEP -1 VAR v FROM Value : v + 0',
+    data, {}, manifest, dest);
+
+// SERIESSTEP 2: every other row
+parser.solve('Sampled = MULTIROWMAP ROWS FROM Rows SERIESSTEP 2 VAR v FROM Value : v + 0',
+    data, {}, manifest, dest);
+```
+
+**Available variables in MULTIROWMAP expressions:**
+- `stepIndex` — iteration counter (0, 1, 2, ...)
+- `rowIndex` — actual array index of the current row
+- Any VAR-mapped variable names
+
+**OFFSET values:**
+- `0` (default) — current row
+- `-1` — previous row, `-2` — two rows back, `-3` — three back, etc.
+- `1` — next row, `2` — two ahead, etc.
+
 ### ITERATIVESERIES
 
 Run cumulative computations over arrays:

package/example_applications/mathematical_playground/AppData.json

@@ -22,5 +22,40 @@
 	"BezierYValues": [0, 1, 4, 9, 16],
 
 	"SalesMonths": [1, 2, 3, 4, 5, 6],
-	"SalesRevenue": [150, 200, 250, 310, 350, 400]
+	"SalesRevenue": [150, 200, 250, 310, 350, 400],
+
+	"FibonacciRows": [
+		{ "Fib": 0 },
+		{ "Fib": 1 },
+		{ "Fib": 1 },
+		{ "Fib": 2 },
+		{ "Fib": 3 },
+		{ "Fib": 5 },
+		{ "Fib": 8 },
+		{ "Fib": 13 },
+		{ "Fib": 21 },
+		{ "Fib": 34 }
+	],
+
+	"StockPrices": [
+		{ "Date": "2025-01-01", "Close": 100.00, "Volume": 5000 },
+		{ "Date": "2025-01-02", "Close": 102.50, "Volume": 6200 },
+		{ "Date": "2025-01-03", "Close": 101.00, "Volume": 4800 },
+		{ "Date": "2025-01-06", "Close": 105.00, "Volume": 7100 },
+		{ "Date": "2025-01-07", "Close": 108.50, "Volume": 8300 },
+		{ "Date": "2025-01-08", "Close": 107.00, "Volume": 5500 },
+		{ "Date": "2025-01-09", "Close": 110.00, "Volume": 6800 },
+		{ "Date": "2025-01-10", "Close": 112.50, "Volume": 7200 }
+	],
+
+	"TemperatureReadings": [
+		{ "Hour": 0, "Temp": 58.0 },
+		{ "Hour": 3, "Temp": 55.5 },
+		{ "Hour": 6, "Temp": 54.0 },
+		{ "Hour": 9, "Temp": 60.5 },
+		{ "Hour": 12, "Temp": 68.0 },
+		{ "Hour": 15, "Temp": 72.5 },
+		{ "Hour": 18, "Temp": 67.0 },
+		{ "Hour": 21, "Temp": 61.5 }
+	]
 }

package/example_applications/mathematical_playground/Math-Solver-Harness.js

@@ -115,4 +115,111 @@ console.log(`  Intercept (baseline): ${tmpSlopeInterceptResults.TrendIntercept}`
 _ExpressionParser.solve('Month7Prediction = TrendIntercept + TrendSlope * 7', tmpSlopeInterceptResults, tmpSlopeInterceptResults, false, tmpSlopeInterceptResults);
 console.log(`  Predicted month 7 revenue: ${tmpSlopeInterceptResults.Month7Prediction}`);
 
+/* * * * * * * * * * * * * * * * *
+ *
+ * MULTIROWMAP: Multi-Row Lookback Series Solver
+ *
+ * MULTIROWMAP lets you iterate over an array of objects (rows) and reference
+ * values from the current row, previous rows, and even future rows.
+ *
+ * Syntax:
+ *   Result = MULTIROWMAP ROWS FROM <address>
+ *     [SERIESSTART <n>]
+ *     [SERIESSTEP <n>]
+ *     VAR <name> FROM <property> [OFFSET <n>] [DEFAULT <value>]
+ *     ...
+ *     : <expression>
+ *
+ * OFFSET 0 (default) = current row
+ * OFFSET -1 = previous row, OFFSET -2 = two rows back, etc.
+ * OFFSET 1 = next row, OFFSET 2 = two rows ahead, etc.
+ * DEFAULT provides a fallback when the referenced row is out of bounds.
+ * SERIESSTART controls which row index to start iterating from (negative counts from end).
+ * SERIESSTEP controls the iteration step (default 1, use -1 to go backwards).
+ *
+ */
+_Fable.log.info(`Beginning MULTIROWMAP Exercises....`);
+
+let tmpMultiRowResults = {};
+
+// --- Example 1: Fibonacci Verification ---
+// Verify that each value in a Fibonacci sequence equals the sum of the two previous values
+_ExpressionParser.solve(
+	'FibCheck = MULTIROWMAP ROWS FROM FibonacciRows VAR Current FROM Fib VAR Prev1 FROM Fib OFFSET -1 DEFAULT 0 VAR Prev2 FROM Fib OFFSET -2 DEFAULT 0 : Current - (Prev1 + Prev2)',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\nFibonacci verification (should be 0 from row 2 onward):`);
+console.log(`  FibCheck: [${tmpMultiRowResults.FibCheck.join(', ')}]`);
+
+// --- Example 2: Stock Price Day-over-Day Change ---
+// Calculate the daily price change for a stock
+_ExpressionParser.solve(
+	'DailyChange = MULTIROWMAP ROWS FROM StockPrices VAR Today FROM Close VAR Yesterday FROM Close OFFSET -1 DEFAULT 0 : Today - Yesterday',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\nStock daily price change:`);
+console.log(`  DailyChange: [${tmpMultiRowResults.DailyChange.join(', ')}]`);
+
+// --- Example 3: 3-Period Moving Average ---
+// Compute a 3-day moving average of stock closing prices
+_ExpressionParser.solve(
+	'MA3 = MULTIROWMAP ROWS FROM StockPrices VAR c0 FROM Close VAR c1 FROM Close OFFSET -1 DEFAULT 0 VAR c2 FROM Close OFFSET -2 DEFAULT 0 : (c0 + c1 + c2) / 3',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\n3-period moving average of stock prices:`);
+console.log(`  MA3: [${tmpMultiRowResults.MA3.join(', ')}]`);
+
+// --- Example 4: Forward-Looking (Next Row Reference) ---
+// For each temperature reading, compute the difference to the next reading
+_ExpressionParser.solve(
+	'TempChange = MULTIROWMAP ROWS FROM TemperatureReadings VAR Current FROM Temp VAR Next FROM Temp OFFSET 1 DEFAULT 0 : Next - Current',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\nTemperature change to next reading (forward lookback):`);
+console.log(`  TempChange: [${tmpMultiRowResults.TempChange.join(', ')}]`);
+
+// --- Example 5: Central Difference (Both Directions) ---
+// Approximate the derivative using central difference: (next - prev) / 2
+_ExpressionParser.solve(
+	'TempDerivative = MULTIROWMAP ROWS FROM TemperatureReadings VAR Prev FROM Temp OFFSET -1 DEFAULT 0 VAR Next FROM Temp OFFSET 1 DEFAULT 0 : (Next - Prev) / 2',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\nTemperature central difference derivative:`);
+console.log(`  TempDerivative: [${tmpMultiRowResults.TempDerivative.join(', ')}]`);
+
+// --- Example 6: Second Derivative (Two-Row Lookback) ---
+// Approximate the second derivative: current - 2*prev + twoprev
+_ExpressionParser.solve(
+	'TempAcceleration = MULTIROWMAP ROWS FROM TemperatureReadings VAR Current FROM Temp VAR Prev FROM Temp OFFSET -1 DEFAULT 0 VAR TwoBack FROM Temp OFFSET -2 DEFAULT 0 : Current - 2 * Prev + TwoBack',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\nTemperature second derivative (acceleration):`);
+console.log(`  TempAcceleration: [${tmpMultiRowResults.TempAcceleration.join(', ')}]`);
+
+// --- Example 7: SERIESSTART - Skip Initial Rows ---
+// Start the moving average from row 2 so all three periods have valid data
+_ExpressionParser.solve(
+	'MA3Valid = MULTIROWMAP ROWS FROM StockPrices SERIESSTART 2 VAR c0 FROM Close VAR c1 FROM Close OFFSET -1 DEFAULT 0 VAR c2 FROM Close OFFSET -2 DEFAULT 0 : (c0 + c1 + c2) / 3',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\n3-period MA starting from row 2 (all periods valid):`);
+console.log(`  MA3Valid: [${tmpMultiRowResults.MA3Valid.join(', ')}]`);
+
+// --- Example 8: SERIESSTEP -1 - Iterate Backwards ---
+// Read stock prices in reverse chronological order
+_ExpressionParser.solve(
+	'ReversePrices = MULTIROWMAP ROWS FROM StockPrices SERIESSTART -1 SERIESSTEP -1 VAR Price FROM Close : Price + 0',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\nStock prices in reverse order:`);
+console.log(`  ReversePrices: [${tmpMultiRowResults.ReversePrices.join(', ')}]`);
+
+// --- Example 9: SERIESSTEP 2 - Every Other Row ---
+// Sample every other temperature reading
+_ExpressionParser.solve(
+	'EveryOtherTemp = MULTIROWMAP ROWS FROM TemperatureReadings SERIESSTEP 2 VAR t FROM Temp : t + 0',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\nEvery other temperature reading:`);
+console.log(`  EveryOtherTemp: [${tmpMultiRowResults.EveryOtherTemp.join(', ')}]`);
+
+// --- Example 10: Three-Row Lookback with Multiple Properties ---
+// Weighted volume change: compare current volume to 3 days ago, scaled by price ratio
+_ExpressionParser.solve(
+	'WeightedVolChange = MULTIROWMAP ROWS FROM StockPrices VAR CurVol FROM Volume VAR CurPrice FROM Close VAR OldVol FROM Volume OFFSET -3 DEFAULT 0 VAR OldPrice FROM Close OFFSET -3 DEFAULT 1 : (CurVol - OldVol) * (CurPrice / OldPrice)',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\nWeighted volume change (3-day lookback with price ratio):`);
+console.log(`  WeightedVolChange: [${tmpMultiRowResults.WeightedVolChange.join(', ')}]`);
+
 console.log('QED');

package/package.json

@@ -1,17 +1,18 @@
 {
   "name": "fable",
-  "version": "3.1.62",
+  "version": "3.1.64",
   "description": "A service dependency injection, configuration and logging library.",
   "main": "source/Fable.js",
   "scripts": {
     "start": "node source/Fable.js",
-    "coverage": "./node_modules/.bin/nyc --reporter=lcov --reporter=text-lcov ./node_modules/mocha/bin/_mocha -- -u tdd -R spec",
-    "test": "./node_modules/.bin/mocha -u tdd -R spec",
+    "coverage": "npx quack coverage",
+    "test": "npx quack test",
     "build": "npx quack build",
+    "prepublishOnly": "npx quack build",
     "docker-dev-build": "docker build ./ -f Dockerfile_LUXURYCode -t fable-image:local",
     "docker-dev-run": "docker run -it -d --name fable-dev -p 30001:8080 -p 38086:8086 -v \"$PWD/.config:/home/coder/.config\"  -v \"$PWD:/home/coder/fable\" -u \"$(id -u):$(id -g)\" -e \"DOCKER_USER=$USER\" fable-image:local",
     "docker-dev-shell": "docker exec -it fable-dev /bin/bash",
-    "tests": "./node_modules/mocha/bin/_mocha -u tdd --exit -R spec --grep"
+    "tests": "npx quack test -g"
   },
   "mocha": {
     "diff": true,
@@ -50,21 +51,21 @@
   },
   "homepage": "https://github.com/stevenvelozo/fable",
   "devDependencies": {
-    "quackage": "^1.0.56"
+    "quackage": "^1.0.59"
   },
   "dependencies": {
     "async.eachlimit": "^0.5.2",
     "async.waterfall": "^0.5.2",
     "big.js": "^7.0.1",
-    "cachetrax": "^1.0.5",
+    "cachetrax": "^1.0.6",
     "cookie": "^1.1.1",
     "data-arithmatic": "^1.0.7",
     "dayjs": "^1.11.19",
-    "fable-log": "^3.0.17",
-    "fable-serviceproviderbase": "^3.0.18",
-    "fable-settings": "^3.0.15",
-    "fable-uuid": "^3.0.12",
-    "manyfest": "^1.0.47",
+    "fable-log": "^3.0.18",
+    "fable-serviceproviderbase": "^3.0.19",
+    "fable-settings": "^3.0.16",
+    "fable-uuid": "^3.0.13",
+    "manyfest": "^1.0.48",
     "simple-get": "^4.0.1"
   }
 }

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-ExpressionTokenizer-DirectiveMutation.js

@@ -13,6 +13,7 @@ class ExpressionTokenizerDirectiveMutation extends libExpressionParserOperationB
 				'SERIES': { Name: 'Series', Code: 'SERIES', From: null, To: null, Step: null },
 				'MONTECARLO': { Name: 'Monte Carlo Simulation', SampleCount: '1', Code: 'MONTECARLO', Values: {} },
 				'MAP': { Name: 'Map', Code: 'MAP', Values: {}, ValueKeys: [] },
+				'MULTIROWMAP': { Name: 'Multi-Row Map', Code: 'MULTIROWMAP', RowsAddress: null, SeriesStart: null, SeriesStep: null, Values: {}, ValueKeys: [] },
 			});
 
 		this.defaultDirective = this.directiveTypes.SOLVE;
@@ -84,7 +85,7 @@ class ExpressionTokenizerDirectiveMutation extends libExpressionParserOperationB
 						let tmpVariableToken = pTokens[i + 1];
 						if (typeof(tmpVariableToken) === 'string' && (tmpVariableToken.length > 0))
 						{
-							tmpNewMonteCarloDirectiveDescription.Values[tmpVariableToken] = 
+							tmpNewMonteCarloDirectiveDescription.Values[tmpVariableToken] =
 							{
 								Token: tmpVariableToken,
 								Easing: 'Linear', // could be parametric, logarithmic, bezier, uniform, normal, etc.
@@ -169,7 +170,7 @@ class ExpressionTokenizerDirectiveMutation extends libExpressionParserOperationB
 						if (typeof(tmpVariableToken) === 'string' && (tmpVariableToken.length > 0))
 						{
 							tmpNewMapDirectiveDescription.ValueKeys.push(tmpVariableToken);
-							tmpNewMapDirectiveDescription.Values[tmpVariableToken] = 
+							tmpNewMapDirectiveDescription.Values[tmpVariableToken] =
 							{
 								Token: tmpVariableToken,
 								Address: pTokens[i + 3],
@@ -188,6 +189,156 @@ class ExpressionTokenizerDirectiveMutation extends libExpressionParserOperationB
 		return tmpNewMapDirectiveDescription;
 	}
 
+	parseMultiRowMapDirective(pTokens)
+	{
+		// Parse MULTIROWMAP directive tokens.
+		// Syntax: MULTIROWMAP ROWS FROM <address> [SERIESSTART <n>] [SERIESSTEP <n>] VAR <name> FROM <property> OFFSET <n> DEFAULT <defaultValue> ...
+		// OFFSET defaults to 0 (current row) if not specified.
+		// DEFAULT defaults to '0' if not specified.
+		// OFFSET 0 = current row, OFFSET -1 = previous row, OFFSET -2 = two rows back, etc.
+		// Positive OFFSET values look forward (e.g., OFFSET 1 = next row, OFFSET 2 = two rows ahead).
+		// SERIESSTART defaults to 0 (first row). Negative values count from the end (e.g., -2 = second-to-last row).
+		// SERIESSTEP defaults to 1. Use -1 to iterate backwards through rows.
+		let tmpNewDirectiveDescription = JSON.parse(JSON.stringify(this.directiveTypes.MULTIROWMAP));
+
+		for (let i = 0; i < pTokens.length; i++)
+		{
+			let tmpToken = pTokens[i].toUpperCase();
+			switch(tmpToken)
+			{
+				case 'ROWS':
+					// Expect ROWS FROM <address>
+					if (((i + 2) < pTokens.length) && (pTokens[i + 1].toUpperCase() === 'FROM'))
+					{
+						tmpNewDirectiveDescription.RowsAddress = pTokens[i + 2];
+						i = i + 2;
+					}
+					break;
+
+				case 'SERIESSTART':
+					if ((i + 1) < pTokens.length)
+					{
+						// Handle negative values which get tokenized as separate - and number tokens
+						let tmpStartValue = pTokens[i + 1];
+						if ((tmpStartValue === '-') && ((i + 2) < pTokens.length))
+						{
+							tmpStartValue = '-' + pTokens[i + 2];
+							i = i + 2;
+						}
+						else
+						{
+							i = i + 1;
+						}
+						tmpNewDirectiveDescription.SeriesStart = tmpStartValue;
+					}
+					break;
+
+				case 'SERIESSTEP':
+					if ((i + 1) < pTokens.length)
+					{
+						// Handle negative values which get tokenized as separate - and number tokens
+						let tmpStepValue = pTokens[i + 1];
+						if ((tmpStepValue === '-') && ((i + 2) < pTokens.length))
+						{
+							tmpStepValue = '-' + pTokens[i + 2];
+							i = i + 2;
+						}
+						else
+						{
+							i = i + 1;
+						}
+						tmpNewDirectiveDescription.SeriesStep = tmpStepValue;
+					}
+					break;
+
+				case 'VARIABLE':
+				case 'VAR':
+				case 'V':
+					// Expect: VAR <name> FROM <property> [OFFSET <n>] [DEFAULT <defaultValue>]
+					if (((i + 3) < pTokens.length) && (pTokens[i + 2].toUpperCase() === 'FROM'))
+					{
+						let tmpVariableName = pTokens[i + 1];
+						let tmpProperty = pTokens[i + 3];
+
+						if (typeof(tmpVariableName) === 'string' && (tmpVariableName.length > 0))
+						{
+							let tmpVariableDescriptor = {
+								Token: tmpVariableName,
+								Property: tmpProperty,
+								RowOffset: 0,
+								Default: '0',
+							};
+
+							let tmpCurrentIndex = i + 3;
+
+							// Scan forward for OFFSET and DEFAULT in any order
+							while (tmpCurrentIndex + 1 < pTokens.length)
+							{
+								let tmpNextToken = pTokens[tmpCurrentIndex + 1].toUpperCase();
+								if (tmpNextToken === 'OFFSET')
+								{
+									if (tmpCurrentIndex + 2 < pTokens.length)
+									{
+										// Handle negative offsets which get tokenized as separate - and number tokens
+										let tmpOffsetValue = pTokens[tmpCurrentIndex + 2];
+										if ((tmpOffsetValue === '-') && (tmpCurrentIndex + 3 < pTokens.length))
+										{
+											tmpOffsetValue = '-' + pTokens[tmpCurrentIndex + 3];
+											tmpCurrentIndex = tmpCurrentIndex + 3;
+										}
+										else
+										{
+											tmpCurrentIndex = tmpCurrentIndex + 2;
+										}
+										tmpVariableDescriptor.RowOffset = parseInt(tmpOffsetValue);
+										if (isNaN(tmpVariableDescriptor.RowOffset))
+										{
+											tmpVariableDescriptor.RowOffset = 0;
+										}
+									}
+								}
+								else if (tmpNextToken === 'DEFAULT')
+								{
+									if (tmpCurrentIndex + 2 < pTokens.length)
+									{
+										// Handle negative defaults which get tokenized as separate - and number tokens
+										let tmpDefaultValue = pTokens[tmpCurrentIndex + 2];
+										if ((tmpDefaultValue === '-') && (tmpCurrentIndex + 3 < pTokens.length))
+										{
+											tmpDefaultValue = '-' + pTokens[tmpCurrentIndex + 3];
+											tmpCurrentIndex = tmpCurrentIndex + 3;
+										}
+										else
+										{
+											tmpCurrentIndex = tmpCurrentIndex + 2;
+										}
+										tmpVariableDescriptor.Default = tmpDefaultValue;
+									}
+								}
+								else
+								{
+									// Not a recognized sub-keyword for this variable; stop scanning
+									break;
+								}
+							}
+
+							i = tmpCurrentIndex;
+
+							tmpNewDirectiveDescription.ValueKeys.push(tmpVariableName);
+							tmpNewDirectiveDescription.Values[tmpVariableName] = tmpVariableDescriptor;
+						}
+					}
+					break;
+
+				default:
+					// Ignore other tokens
+					break;
+			}
+		}
+
+		return tmpNewDirectiveDescription;
+	}
+
 	parseDirectives(pResultObject)
 	{
 		let tmpResults = (typeof(pResultObject) === 'object') ? pResultObject : { ExpressionParserLog: [] };
@@ -258,6 +409,9 @@ class ExpressionTokenizerDirectiveMutation extends libExpressionParserOperationB
 						case 'MAP':
 							tmpResults.SolverDirectives = this.parseMapDirective(tmpResults.SolverDirectiveTokens);
 							break;
+						case 'MULTIROWMAP':
+							tmpResults.SolverDirectives = this.parseMultiRowMapDirective(tmpResults.SolverDirectiveTokens);
+							break;
 						default:
 							// No further parsing needed
 							break;

package/source/services/Fable-Service-ExpressionParser.js

@@ -456,6 +456,149 @@ class FableServiceExpressionParser extends libFableServiceBase
 
 			return tmpValueArray;
 		}
+		else if (tmpResultsObject.SolverDirectives.Code == 'MULTIROWMAP')
+		{
+			// MULTIROWMAP iterates over an array of objects (rows), allowing each expression to reference
+			// the current row and any number of previous/future rows via configurable offsets.
+			// Optional SERIESSTART and SERIESSTEP control which rows are iterated and in what direction.
+			const tmpDirectiveValues = tmpResultsObject.SolverDirectives.Values;
+			const tmpDirectiveValueKeys = tmpResultsObject.SolverDirectives.ValueKeys;
+			const tmpRowsAddress = tmpResultsObject.SolverDirectives.RowsAddress;
+			let tmpValueArray = [];
+
+			// Resolve the rows array from the data source
+			let tmpRows = null;
+			if (tmpRowsAddress)
+			{
+				tmpRows = tmpManifest.getValueByHash(tmpDataSourceObject, tmpRowsAddress);
+			}
+
+			if (!Array.isArray(tmpRows) || tmpRows.length < 1)
+			{
+				tmpResultsObject.ExpressionParserLog.push(`ExpressionParser.solve detected invalid MULTIROWMAP directive parameters.  ROWS FROM address must resolve to a non-empty array.`);
+				this.log.warn(tmpResultsObject.ExpressionParserLog[tmpResultsObject.ExpressionParserLog.length-1]);
+				return undefined;
+			}
+
+			// Resolve SeriesStart: default to 0 (first row).  Negative values count from end.
+			let tmpSeriesStart = 0;
+			if (tmpResultsObject.SolverDirectives.SeriesStart !== null)
+			{
+				tmpSeriesStart = parseInt(tmpResultsObject.SolverDirectives.SeriesStart);
+				if (isNaN(tmpSeriesStart))
+				{
+					// Try to resolve as a variable from the data source
+					let tmpStartToken = this.fable.ExpressionParser.Postfix.getTokenContainerObject(tmpResultsObject.SolverDirectives.SeriesStart, 'Token.Symbol');
+					this.substituteValuesInTokenizedObjects([tmpStartToken], tmpDataSourceObject, tmpResultsObject, tmpManifest);
+					if (tmpStartToken.Resolved)
+					{
+						tmpSeriesStart = parseInt(tmpStartToken.Value);
+					}
+					if (isNaN(tmpSeriesStart))
+					{
+						tmpSeriesStart = 0;
+					}
+				}
+			}
+			// Handle negative start (count from end)
+			if (tmpSeriesStart < 0)
+			{
+				tmpSeriesStart = tmpRows.length + tmpSeriesStart;
+			}
+			// Clamp to valid range
+			tmpSeriesStart = Math.max(0, Math.min(tmpSeriesStart, tmpRows.length - 1));
+
+			// Resolve SeriesStep: default to 1
+			let tmpSeriesStep = 1;
+			if (tmpResultsObject.SolverDirectives.SeriesStep !== null)
+			{
+				tmpSeriesStep = parseInt(tmpResultsObject.SolverDirectives.SeriesStep);
+				if (isNaN(tmpSeriesStep))
+				{
+					// Try to resolve as a variable from the data source
+					let tmpStepToken = this.fable.ExpressionParser.Postfix.getTokenContainerObject(tmpResultsObject.SolverDirectives.SeriesStep, 'Token.Symbol');
+					this.substituteValuesInTokenizedObjects([tmpStepToken], tmpDataSourceObject, tmpResultsObject, tmpManifest);
+					if (tmpStepToken.Resolved)
+					{
+						tmpSeriesStep = parseInt(tmpStepToken.Value);
+					}
+					if (isNaN(tmpSeriesStep))
+					{
+						tmpSeriesStep = 1;
+					}
+				}
+			}
+			if (tmpSeriesStep === 0)
+			{
+				tmpResultsObject.ExpressionParserLog.push(`ExpressionParser.solve detected invalid MULTIROWMAP directive parameters.  SERIESSTEP cannot be zero.`);
+				this.log.warn(tmpResultsObject.ExpressionParserLog[tmpResultsObject.ExpressionParserLog.length-1]);
+				return undefined;
+			}
+
+			let tmpStepCounter = 0;
+			for (let i = tmpSeriesStart; (tmpSeriesStep > 0) ? (i < tmpRows.length) : (i >= 0); i += tmpSeriesStep)
+			{
+				// Build the data source for this iteration with the mapped variables
+				let tmpRowStepDataSourceObject = Object.assign({}, tmpDataSourceObject);
+				tmpRowStepDataSourceObject.stepIndex = tmpStepCounter;
+				tmpRowStepDataSourceObject.rowIndex = i;
+
+				for (let j = 0; j < tmpDirectiveValueKeys.length; j++)
+				{
+					const tmpVariableKey = tmpDirectiveValueKeys[j];
+					const tmpVariableDescription = tmpDirectiveValues[tmpVariableKey];
+					const tmpTargetRowIndex = i + tmpVariableDescription.RowOffset;
+
+					// Check if the target row index is within bounds
+					if (tmpTargetRowIndex < 0 || tmpTargetRowIndex >= tmpRows.length)
+					{
+						// Out of bounds -- use the default value
+						tmpRowStepDataSourceObject[tmpVariableKey] = tmpVariableDescription.Default;
+					}
+					else
+					{
+						const tmpTargetRow = tmpRows[tmpTargetRowIndex];
+						if (tmpVariableDescription.Property === null)
+						{
+							// No property specified, use the whole row
+							tmpRowStepDataSourceObject[tmpVariableKey] = tmpTargetRow;
+						}
+						else
+						{
+							// Look up the property on the target row
+							let tmpValue = tmpManifest.getValueByHash(tmpTargetRow, tmpVariableDescription.Property);
+							if (tmpValue == null)
+							{
+								tmpValue = tmpVariableDescription.Default;
+							}
+							tmpRowStepDataSourceObject[tmpVariableKey] = tmpValue;
+						}
+					}
+				}
+
+				let tmpMutatedValues = this.substituteValuesInTokenizedObjects(tmpResultsObject.PostfixTokenObjects, tmpRowStepDataSourceObject, tmpResultsObject, tmpManifest);
+
+				tmpValueArray.push( this.solvePostfixedExpression( tmpResultsObject.PostfixSolveList, tmpDataDestinationObject, tmpResultsObject, tmpManifest) );
+
+				for (let j = 0; j < tmpMutatedValues.length; j++)
+				{
+					tmpMutatedValues[j].Resolved = false;
+				}
+
+				tmpStepCounter++;
+			}
+
+			// Do the assignment
+			let tmpAssignmentManifestHash = tmpResultsObject.PostfixedAssignmentAddress;
+			if ((tmpResultsObject.OriginalRawTokens[1] === '=') && (typeof(tmpResultsObject.OriginalRawTokens[0]) === 'string') && (tmpResultsObject.OriginalRawTokens[0].length > 0))
+			{
+				tmpAssignmentManifestHash = tmpResultsObject.OriginalRawTokens[0];
+			}
+
+			tmpManifest.setValueByHash(tmpDataDestinationObject, tmpAssignmentManifestHash, tmpValueArray);
+
+			return tmpValueArray;
+		}
 		else if (tmpResultsObject.SolverDirectives.Code == 'MONTECARLO')
 		{
 			const [ tmpSampleCount ] = this._prepareDirectiveParameters([