mcp-server-sfmc 1.9.2 → 2.1.0

package/dist/conversion-rules.js

@@ -37,6 +37,48 @@ export const AMP_TO_PLATFORM_FUNCTION = Object.fromEntries(PLATFORM_FUNCTIONS.fi
  */
 const SSJS_ONLY_FUNCTIONS = new Set(PLATFORM_FUNCTIONS.filter((f) => f.ampscriptEquivalent === null).map((f) => f.name.toLowerCase()));
 // ---------------------------------------------------------------------------
+// Dynamic AMPscript ↔ MCN Handlebars maps (built from ampscript-data at load time)
+// ---------------------------------------------------------------------------
+import { FUNCTIONS as AMPSCRIPT_FUNCTIONS } from 'ampscript-data';
+import { getHelper as getHandlebarsHelper } from 'handlebars-data';
+/**
+ * Maps an AMPscript function name (lowercase) to the canonical MCN Handlebars
+ * helper name it converts to. Built at module load time from ampscript-data's
+ * `handlebarsEquivalent` field — always in sync with the installed
+ * ampscript-data version, never hand-edited (`mcp-conversion-rules-sync.mdc`).
+ *
+ * Only Category A functions (non-null string `handlebarsEquivalent`) are
+ * included. The stored value is the bare helper name; the canonical casing is
+ * resolved through `handlebars-data` so emitted `{{helper}}` calls match the
+ * catalog exactly.
+ */
+export const AMP_TO_HANDLEBARS = Object.fromEntries(AMPSCRIPT_FUNCTIONS.filter((f) => typeof f.handlebarsEquivalent === 'string' && f.handlebarsEquivalent.length > 0).map((f) => {
+    const canonical = getHandlebarsHelper(f.handlebarsEquivalent);
+    return [
+        f.name.toLowerCase(),
+        canonical ? canonical.name : f.handlebarsEquivalent,
+    ];
+}));
+/**
+ * Maps a canonical MCN Handlebars helper name (lowercase) to its AMPscript
+ * function name. Inverted from AMP_TO_HANDLEBARS at module load time. Used by
+ * convertHandlebarsToAmpscript.
+ */
+export const HANDLEBARS_TO_AMP = Object.fromEntries(AMPSCRIPT_FUNCTIONS.filter((f) => typeof f.handlebarsEquivalent === 'string' && f.handlebarsEquivalent.length > 0).map((f) => {
+    const canonical = getHandlebarsHelper(f.handlebarsEquivalent);
+    return [
+        (canonical ? canonical.name : f.handlebarsEquivalent).toLowerCase(),
+        f.name,
+    ];
+}));
+/**
+ * Set of AMPscript function names (lowercase) flagged `mcnHandlebarsGap: true`
+ * in ampscript-data (Category C). These are documented as MCN-supported but
+ * currently fail at runtime and have no Handlebars helper — converting them
+ * must emit a MANUAL_REWRITE marker distinct from Category B (no counterpart).
+ */
+export const AMP_MCN_HANDLEBARS_GAP = new Set(AMPSCRIPT_FUNCTIONS.filter((f) => f.mcnHandlebarsGap === true).map((f) => f.name.toLowerCase()));
+// ---------------------------------------------------------------------------
 // AMP_NATIVE_JS_HINTS: AMPscript-only functions with clean native JS rewrites
 // ---------------------------------------------------------------------------
 /**
@@ -165,6 +207,17 @@ export const NON_MIGRATABLE_SSJS_PATTERNS = [
         reason: 'Query string / form field access requires CloudPages context (not available in MCN)',
     },
 ];
+/**
+ * Returns the first non-migratable SSJS pattern that matches the given code, or undefined.
+ * @param code single line of trimmed SSJS source
+ */
+function findNonMigratableSsjsPattern(code) {
+    return NON_MIGRATABLE_SSJS_PATTERNS.find(({ pattern }) => {
+        // Reset lastIndex for global regexes
+        pattern.lastIndex = 0;
+        return pattern.test(code);
+    });
+}
 // ---------------------------------------------------------------------------
 // SSJS → AMPscript conversion
 // ---------------------------------------------------------------------------
@@ -195,8 +248,8 @@ export function ssjsToAmpscript(code) {
         .trim();
     const rawLines = inner.split('\n');
     const outputLines = [];
-    for (const [i, original] of rawLines.entries()) {
-        const lineNum = i + 1;
+    for (const [index, original] of rawLines.entries()) {
+        const lineNumber = index + 1;
         const trimmed = original.trim();
         // Skip blank lines, Platform.Load(), var-only declarations with no value
         if (!trimmed) {
@@ -206,111 +259,107 @@ export function ssjsToAmpscript(code) {
         // Skip Platform.Load() — no AMPscript equivalent, not needed in MCN
         if (/^Platform\.Load\s*\(/i.test(trimmed)) {
             changes.push({
-                line: lineNum,
+                line: lineNumber,
                 description: 'Removed Platform.Load() (not needed in AMPscript)',
             });
             continue;
         }
         // Check for non-migratable patterns first
-        let isFlagged = false;
-        for (const { pattern, reason } of NON_MIGRATABLE_SSJS_PATTERNS) {
-            // Reset lastIndex for global regexes
-            pattern.lastIndex = 0;
-            if (pattern.test(trimmed)) {
-                outputLines.push(`%%-- MANUAL_REWRITE_REQUIRED: ${reason} --%%`, `%%-- Original: ${trimmed} --%%`);
-                flaggedSections.push({ line: lineNum, code: trimmed, reason });
-                isFlagged = true;
-                break;
-            }
-        }
-        if (isFlagged) {
+        const nonMigratable = findNonMigratableSsjsPattern(trimmed);
+        if (nonMigratable) {
+            const { reason } = nonMigratable;
+            outputLines.push(`%%-- MANUAL_REWRITE_REQUIRED: ${reason} --%%`, `%%-- Original: ${trimmed} --%%`);
+            flaggedSections.push({ line: lineNumber, code: trimmed, reason });
             continue;
         }
         let line = original;
         // Platform.Variable.GetValue("name") → @name
         line = line.replaceAll(/Platform\.Variable\.GetValue\s*\(\s*["']([^"']+)["']\s*\)/gi, '@$1');
         // Platform.Variable.SetValue("name", value) → SET @name = value (strip ; at end if present)
-        line = line.replaceAll(/Platform\.Variable\.SetValue\s*\(\s*["']([^"']+)["']\s*,\s*([^)]+)\)\s*;?/gi, (_, varName, value) => {
+        line = line.replaceAll(/Platform\.Variable\.SetValue\s*\(\s*["']([^"']+)["']\s*,\s*([^)]+)\)\s*;?/gi, (_, variableName, value) => {
             changes.push({
-                line: lineNum,
-                description: `Platform.Variable.SetValue → SET @${varName}`,
+                line: lineNumber,
+                description: `Platform.Variable.SetValue → SET @${variableName}`,
             });
-            return `SET @${varName} = ${value.trim()}`;
+            return `SET @${variableName} = ${value.trim()}`;
         });
         // Platform.Response.Write(expr) → OutputLine(expr)
         line = line.replaceAll(/Platform\.Response\.Write\s*\(/gi, () => {
-            changes.push({ line: lineNum, description: 'Platform.Response.Write → OutputLine' });
+            changes.push({ line: lineNumber, description: 'Platform.Response.Write → OutputLine' });
             return 'OutputLine(';
         });
         // Platform.Function.X(args) → X(args) using known function map
-        line = line.replaceAll(/Platform\.Function\.(\w+)\s*\(/gi, (_, fnName) => {
-            const key = fnName.toLowerCase();
+        line = line.replaceAll(/Platform\.Function\.(\w+)\s*\(/gi, (_, functionName) => {
+            const key = functionName.toLowerCase();
             if (SSJS_ONLY_FUNCTIONS.has(key)) {
                 flaggedSections.push({
-                    line: lineNum,
-                    code: `Platform.Function.${fnName}(...)`,
-                    reason: `Platform.Function.${fnName} has no AMPscript equivalent`,
+                    line: lineNumber,
+                    code: `Platform.Function.${functionName}(...)`,
+                    reason: `Platform.Function.${functionName} has no AMPscript equivalent`,
                 });
-                return `/* MANUAL_REWRITE_REQUIRED: Platform.Function.${fnName} has no AMPscript equivalent */ ${fnName}(`;
+                return `/* MANUAL_REWRITE_REQUIRED: Platform.Function.${functionName} has no AMPscript equivalent */ ${functionName}(`;
             }
             const ampName = PLATFORM_FUNCTION_TO_AMP[key];
             if (!ampName) {
                 flaggedSections.push({
-                    line: lineNum,
-                    code: `Platform.Function.${fnName}(...)`,
-                    reason: `Platform.Function.${fnName} not found in ssjs-data catalog`,
+                    line: lineNumber,
+                    code: `Platform.Function.${functionName}(...)`,
+                    reason: `Platform.Function.${functionName} not found in ssjs-data catalog`,
                 });
-                return `/* MANUAL_REWRITE_REQUIRED: unknown Platform.Function.${fnName} */ ${fnName}(`;
+                return `/* MANUAL_REWRITE_REQUIRED: unknown Platform.Function.${functionName} */ ${functionName}(`;
             }
             changes.push({
-                line: lineNum,
-                description: `Platform.Function.${fnName} → ${ampName}`,
+                line: lineNumber,
+                description: `Platform.Function.${functionName} → ${ampName}`,
             });
             return `${ampName}(`;
         });
         // var x = expr; → SET @x = expr
-        line = line.replace(/\bvar\s+([A-Za-z_]\w*)\s*=\s*(.+?)\s*;?\s*$/, (_, varName, value) => {
+        line = line.replace(/\bvar\s+([A-Za-z_]\w*)\s*=\s*(.+?)\s*;?\s*$/, (_, variableName, value) => {
             changes.push({
-                line: lineNum,
-                description: `var ${varName} = ... → SET @${varName}`,
+                line: lineNumber,
+                description: `var ${variableName} = ... → SET @${variableName}`,
             });
-            return `SET @${varName} = ${value.trim()}`;
+            return `SET @${variableName} = ${value.trim()}`;
         });
         // var x; → VAR @x
-        line = line.replace(/\bvar\s+([A-Za-z_]\w*)\s*;?\s*$/, (_, varName) => {
-            changes.push({ line: lineNum, description: `var ${varName} → VAR @${varName}` });
-            return `VAR @${varName}`;
+        line = line.replace(/\bvar\s+([A-Za-z_]\w*)\s*;?\s*$/, (_, variableName) => {
+            changes.push({
+                line: lineNumber,
+                description: `var ${variableName} → VAR @${variableName}`,
+            });
+            return `VAR @${variableName}`;
         });
         // Control flow: if (cond) { → IF cond THEN
         line = line.replace(/^\s*if\s*\((.+)\)\s*\{\s*$/, (_, cond) => {
             const ampCond = ssjsCondToAmp(cond.trim());
-            changes.push({ line: lineNum, description: 'if (...) { → IF ... THEN' });
+            changes.push({ line: lineNumber, description: 'if (...) { → IF ... THEN' });
             return `IF ${ampCond} THEN`;
         });
         // } else if (cond) { → ELSEIF cond THEN
         line = line.replace(/^\s*\}\s*else\s+if\s*\((.+)\)\s*\{\s*$/, (_, cond) => {
             const ampCond = ssjsCondToAmp(cond.trim());
-            changes.push({ line: lineNum, description: '} else if (...) { → ELSEIF ... THEN' });
+            changes.push({ line: lineNumber, description: '} else if (...) { → ELSEIF ... THEN' });
             return `ELSEIF ${ampCond} THEN`;
         });
         // } else { → ELSE
         line = line.replace(/^\s*\}\s*else\s*\{\s*$/, () => {
-            changes.push({ line: lineNum, description: '} else { → ELSE' });
+            changes.push({ line: lineNumber, description: '} else { → ELSE' });
             return 'ELSE';
         });
         // for (var i = start; i <= end; i++) { → FOR @i = start TO end DO
         const forMatch = /^\s*for\s*\(\s*var\s+(\w+)\s*=\s*(\S+?)\s*;\s*\w+\s*<=?\s*(\S+?)\s*;\s*\w+\+\+\s*\)\s*\{\s*$/.exec(line);
         if (forMatch) {
-            const [, iterVar, start, end] = forMatch;
+            const [, iterVariable, start, end] = forMatch;
             changes.push({
-                line: lineNum,
-                description: `for (var ${iterVar}...) → FOR @${iterVar} = ${start} TO ${end} DO`,
+                line: lineNumber,
+                description: `for (var ${iterVariable}...) → FOR @${iterVariable} = ${start} TO ${end} DO`,
             });
-            line = `FOR @${iterVar} = ${start} TO ${end} DO`;
+            line = `FOR @${iterVariable} = ${start} TO ${end} DO`;
         }
         // Standalone closing brace } → ENDIF (best-effort; may not always be correct)
         if (/^\s*\}\s*$/.test(line) && !/^\s*\}\s*(else|catch|finally)/.test(line)) {
-            changes.push({ line: lineNum, description: '} → ENDIF' });
+            changes.push({ line: lineNumber, description: '} → ENDIF' });
             line = 'ENDIF';
         }
         // Strip trailing semicolons from non-SET lines (AMPscript doesn't use them)
@@ -366,8 +415,8 @@ export function ampscriptToSsjs(code) {
     const normalized = normalizeAmpscriptBlocks(code);
     const lines = normalized.split('\n');
     const lineOffset = 0;
-    for (const [i, line] of lines.entries()) {
-        const lineNum = i + 1 + lineOffset;
+    for (const [index, line] of lines.entries()) {
+        const lineNumber = index + 1 + lineOffset;
         const trimmed = line.trim();
         if (!trimmed) {
             outputLines.push('');
@@ -376,51 +425,52 @@ export function ampscriptToSsjs(code) {
         // %%=Output(@x)=%% or %%=OutputLine(@x)=%%
         const inlineOutputMatch = /^%%=\s*(?:Output|OutputLine)\s*\((.+)\)\s*=%%$/i.exec(trimmed);
         if (inlineOutputMatch) {
-            const expr = stripAmpVars(inlineOutputMatch[1].trim());
+            const expression = stripAmpVars(inlineOutputMatch[1].trim());
             changes.push({
-                line: lineNum,
+                line: lineNumber,
                 description: '%%=Output(...)=%% → Platform.Response.Write(...)',
             });
-            outputLines.push(`Platform.Response.Write(${expr});`);
+            outputLines.push(`Platform.Response.Write(${expression});`);
             continue;
         }
         // %%=FunctionName(args)=%% → Platform.Response.Write(Platform.Function.FunctionName(args))
-        const inlineFnMatch = /^%%=\s*(\w+)\s*\((.*)?\)\s*=%%$/i.exec(trimmed);
-        if (inlineFnMatch) {
-            const fnName = inlineFnMatch[1];
-            const args = inlineFnMatch[2]?.trim() ?? '';
-            const key = fnName.toLowerCase();
+        const inlineFunctionMatch = /^%%=\s*(\w+)\s*\((.*)?\)\s*=%%$/i.exec(trimmed);
+        if (inlineFunctionMatch) {
+            const functionName = inlineFunctionMatch[1];
+            const arguments_ = inlineFunctionMatch[2]?.trim() ?? '';
+            const key = functionName.toLowerCase();
             const ssName = AMP_TO_PLATFORM_FUNCTION[key];
-            const argsConverted = stripAmpVars(args);
+            const nativeHint = AMP_NATIVE_JS_HINTS[key];
+            const argumentsConverted = stripAmpVars(arguments_);
             if (ssName) {
                 changes.push({
-                    line: lineNum,
-                    description: `%%=${fnName}(...)=%% → Platform.Response.Write(Platform.Function.${ssName}(...))`,
+                    line: lineNumber,
+                    description: `%%=${functionName}(...)=%% → Platform.Response.Write(Platform.Function.${ssName}(...))`,
                 });
-                outputLines.push(`Platform.Response.Write(Platform.Function.${ssName}(${argsConverted}));`);
+                outputLines.push(`Platform.Response.Write(Platform.Function.${ssName}(${argumentsConverted}));`);
             }
-            else if (AMP_NATIVE_JS_HINTS[key]) {
+            else if (nativeHint) {
                 changes.push({
-                    line: lineNum,
-                    description: `%%=${fnName}(...)=%% → native JS hint`,
+                    line: lineNumber,
+                    description: `%%=${functionName}(...)=%% → native JS hint`,
                 });
-                outputLines.push(`Platform.Response.Write(${AMP_NATIVE_JS_HINTS[key]} /* AMPscript: ${fnName}(${args}) */);`);
+                outputLines.push(`Platform.Response.Write(${nativeHint} /* AMPscript: ${functionName}(${arguments_}) */);`);
             }
             else if (CLOUDPAGES_ONLY_FUNCTIONS.has(key)) {
                 // CloudPages-only function
-                outputLines.push(`/* MANUAL_REWRITE_REQUIRED: %%=${fnName}(${args})=%% */`);
+                outputLines.push(`/* MANUAL_REWRITE_REQUIRED: %%=${functionName}(${arguments_})=%% */`);
                 flaggedSections.push({
-                    line: lineNum,
+                    line: lineNumber,
                     code: trimmed,
-                    reason: `AMPscript function '${fnName}' is CloudPages-only — no SSJS equivalent`,
+                    reason: `AMPscript function '${functionName}' is CloudPages-only — no SSJS equivalent`,
                 });
             }
             else {
                 // AMP-only function with no native hint → polyfill
                 polyfillUsed.value = true;
                 changes.push({
-                    line: lineNum,
-                    description: `%%=${fnName}(...)=%% → _ampScript polyfill`,
+                    line: lineNumber,
+                    description: `%%=${functionName}(...)=%% → _ampScript polyfill`,
                 });
                 outputLines.push(`Platform.Response.Write(_ampScript('${trimmed.replaceAll("'", String.raw `\'`)}'));`);
             }
@@ -430,9 +480,9 @@ export function ampscriptToSsjs(code) {
         const blockMatch = /^%%\[\s*([\s\S]*?)\s*\]%%$/i.exec(trimmed);
         if (blockMatch) {
             const blockContent = blockMatch[1].trim();
-            const stmts = blockContent.split(/\n+/);
-            for (const stmt of stmts) {
-                const converted = convertAmpStatement(stmt.trim(), lineNum, changes, flaggedSections, polyfillUsed);
+            const statements = blockContent.split(/\n+/);
+            for (const statement of statements) {
+                const converted = convertAmpStatement(statement.trim(), lineNumber, changes, flaggedSections, polyfillUsed);
                 if (converted !== null) {
                     outputLines.push(converted);
                 }
@@ -441,7 +491,7 @@ export function ampscriptToSsjs(code) {
         }
         // Bare AMPscript statement (already stripped of delimiters from normalizeAmpscriptBlocks)
         if (/^(SET|VAR|IF|ELSEIF|ELSE|ENDIF|FOR|NEXT|OUTPUT|OUTPUTLINE)\b/i.test(trimmed)) {
-            const converted = convertAmpStatement(trimmed, lineNum, changes, flaggedSections, polyfillUsed);
+            const converted = convertAmpStatement(trimmed, lineNumber, changes, flaggedSections, polyfillUsed);
             if (converted !== null) {
                 outputLines.push(converted);
             }
@@ -449,7 +499,7 @@ export function ampscriptToSsjs(code) {
         }
         // Bare function call or other AMPscript statement inside a normalized block
         if (/^\w+\s*\(/.test(trimmed)) {
-            const converted = convertAmpStatement(trimmed, lineNum, changes, flaggedSections, polyfillUsed);
+            const converted = convertAmpStatement(trimmed, lineNumber, changes, flaggedSections, polyfillUsed);
             if (converted !== null) {
                 outputLines.push(converted);
             }
@@ -505,40 +555,42 @@ function convertAmpStatement(stmt, lineNum, changes, flaggedSections, polyfillUs
     // SET @x = expr → var x = expr;
     const setMatch = /^SET\s+@(\w+)\s*=\s*(.+)$/i.exec(stmt);
     if (setMatch) {
-        const [, varName, expr] = setMatch;
-        const exprTrimmed = expr.trim();
+        const [, variableName, expression] = setMatch;
+        const expressionTrimmed = expression.trim();
         // Check if the expression is a single AMP-only function call with no Platform.Function equivalent
         // and no native JS hint — if so, emit _ampScript polyfill rather than a broken expression.
-        const singleFnMatch = /^(\w+)\s*\(/.exec(exprTrimmed);
-        if (singleFnMatch) {
-            const key = singleFnMatch[1].toLowerCase();
+        const singleFunctionMatch = /^(\w+)\s*\(/.exec(expressionTrimmed);
+        if (singleFunctionMatch) {
+            const key = singleFunctionMatch[1].toLowerCase();
             const hasSsjsEquiv = AMP_TO_PLATFORM_FUNCTION[key] !== undefined;
             const hasNativeHint = AMP_NATIVE_JS_HINTS[key] !== undefined;
             if (!hasSsjsEquiv && !hasNativeHint && !CLOUDPAGES_ONLY_FUNCTIONS.has(key)) {
                 polyfillUsed.value = true;
                 changes.push({
                     line: lineNum,
-                    description: `SET @${varName} = ${singleFnMatch[1]}(...) → _ampScript polyfill`,
+                    description: `SET @${variableName} = ${singleFunctionMatch[1]}(...) → _ampScript polyfill`,
                 });
-                return `var ${varName} = _ampScript('${exprTrimmed.replaceAll("'", String.raw `\'`)}');`;
+                return `var ${variableName} = _ampScript('${expressionTrimmed.replaceAll("'", String.raw `\'`)}');`;
             }
         }
-        const ssExpr = convertAmpExpr(exprTrimmed);
+        const ssExpression = convertAmpExpression(expressionTrimmed);
         changes.push({
             line: lineNum,
-            description: `SET @${varName} = ... → var ${varName} = ...`,
+            description: `SET @${variableName} = ... → var ${variableName} = ...`,
         });
-        return `var ${varName} = ${ssExpr};`;
+        return `var ${variableName} = ${ssExpression};`;
     }
     // VAR @x, @y → var x, y;
-    const varMatch = /^VAR\s+(.+)$/i.exec(stmt);
-    if (varMatch) {
-        const vars = varMatch[1].split(',').map((v) => v.trim().replace(/^@/, ''));
+    const variableMatch = /^VAR\s+(.+)$/i.exec(stmt);
+    if (variableMatch) {
+        const variables = variableMatch[1]
+            .split(',')
+            .map((v) => v.trim().replace(/^@/, ''));
         changes.push({
             line: lineNum,
-            description: `VAR @${vars.join(', @')} → var ${vars.join(', ')}`,
+            description: `VAR @${variables.join(', @')} → var ${variables.join(', ')}`,
         });
-        return `var ${vars.join(', ')};`;
+        return `var ${variables.join(', ')};`;
     }
     // IF cond THEN → if (cond) {
     const ifMatch = /^IF\s+(.+?)\s+THEN$/i.exec(stmt);
@@ -567,14 +619,14 @@ function convertAmpStatement(stmt, lineNum, changes, flaggedSections, polyfillUs
     // FOR @i = start TO end DO → for (var i = start; i <= end; i++) {
     const forMatch = /^FOR\s+@(\w+)\s*=\s*(\S+?)\s+TO\s+(\S+?)(?:\s+STEP\s+\S+)?\s+DO$/i.exec(stmt);
     if (forMatch) {
-        const [, iterVar, start, end] = forMatch;
+        const [, iterVariable, start, end] = forMatch;
         const ssStart = stripAmpVars(start);
         const ssEnd = stripAmpVars(end);
         changes.push({
             line: lineNum,
-            description: `FOR @${iterVar} = ${start} TO ${end} DO → for loop`,
+            description: `FOR @${iterVariable} = ${start} TO ${end} DO → for loop`,
         });
-        return `for (var ${iterVar} = ${ssStart}; ${iterVar} <= ${ssEnd}; ${iterVar}++) {`;
+        return `for (var ${iterVariable} = ${ssStart}; ${iterVariable} <= ${ssEnd}; ${iterVariable}++) {`;
     }
     // NEXT @i → }
     if (/^NEXT\s+@\w+$/i.test(stmt)) {
@@ -584,23 +636,23 @@ function convertAmpStatement(stmt, lineNum, changes, flaggedSections, polyfillUs
     // OUTPUT(expr) / OUTPUTLINE(expr) → Platform.Response.Write(expr)
     const outputMatch = /^(?:OUTPUT|OUTPUTLINE)\s*\((.+)\)$/i.exec(stmt);
     if (outputMatch) {
-        const expr = convertAmpExpr(outputMatch[1].trim());
+        const expression = convertAmpExpression(outputMatch[1].trim());
         changes.push({ line: lineNum, description: 'Output/OutputLine → Platform.Response.Write' });
-        return `Platform.Response.Write(${expr});`;
+        return `Platform.Response.Write(${expression});`;
     }
     // Known AMPscript function call → Platform.Function.X(args)
-    const fnCallMatch = /^(\w+)\s*\((.*)?\)$/i.exec(stmt);
-    if (fnCallMatch) {
-        const [, fnName, args] = fnCallMatch;
-        const key = fnName.toLowerCase();
+    const functionCallMatch = /^(\w+)\s*\((.*)?\)$/i.exec(stmt);
+    if (functionCallMatch) {
+        const [, functionName, arguments_] = functionCallMatch;
+        const key = functionName.toLowerCase();
         const ssName = AMP_TO_PLATFORM_FUNCTION[key];
         if (ssName) {
-            const argsConverted = args ? convertAmpExpr(args.trim()) : '';
+            const argumentsConverted = arguments_ ? convertAmpExpression(arguments_.trim()) : '';
             changes.push({
                 line: lineNum,
-                description: `${fnName}(…) → Platform.Function.${ssName}(…)`,
+                description: `${functionName}(…) → Platform.Function.${ssName}(…)`,
             });
-            return `Platform.Function.${ssName}(${argsConverted});`;
+            return `Platform.Function.${ssName}(${argumentsConverted});`;
         }
         // CloudPages-only functions have no SSJS/MCN equivalent
         if (CLOUDPAGES_ONLY_FUNCTIONS.has(key)) {
@@ -616,7 +668,7 @@ function convertAmpStatement(stmt, lineNum, changes, flaggedSections, polyfillUs
         if (hint) {
             changes.push({
                 line: lineNum,
-                description: `${fnName}(…) → native JS equivalent`,
+                description: `${functionName}(…) → native JS equivalent`,
             });
             return `${hint} /* AMPscript: ${stmt} */`;
         }
@@ -624,7 +676,7 @@ function convertAmpStatement(stmt, lineNum, changes, flaggedSections, polyfillUs
         polyfillUsed.value = true;
         changes.push({
             line: lineNum,
-            description: `${fnName}(…) → _ampScript polyfill (no direct SSJS equivalent)`,
+            description: `${functionName}(…) → _ampScript polyfill (no direct SSJS equivalent)`,
         });
         return `_ampScript('${stmt.replaceAll("'", String.raw `\'`)}');`;
     }
@@ -655,21 +707,21 @@ function convertAmpStatement(stmt, lineNum, changes, flaggedSections, polyfillUs
  * @param expr - AMPscript expression string.
  * @returns {string} SSJS expression string.
  */
-function convertAmpExpr(expr) {
+function convertAmpExpression(expr) {
     // Replace known AMPscript function calls with Platform.Function.X equivalents;
     // emit a hint comment for native-hint functions; leave others with a MANUAL_REWRITE comment.
     // Note: AMP-only functions used in a SET assignment are handled at the statement level
     // (convertAmpStatement SET handler) which emits _ampScript(...) for the whole expression.
-    let result = expr.replaceAll(/\b(\w+)\s*\(/g, (match, fnName) => {
-        const key = fnName.toLowerCase();
+    let result = expr.replaceAll(/\b(\w+)\s*\(/g, (match, functionName) => {
+        const key = functionName.toLowerCase();
         const ssName = AMP_TO_PLATFORM_FUNCTION[key];
         if (ssName)
             return `Platform.Function.${ssName}(`;
         const hint = AMP_NATIVE_JS_HINTS[key];
         if (hint)
-            return `${hint} /* ${fnName}( */`;
+            return `${hint} /* ${functionName}( */`;
         // Unknown function in expression context — annotate
-        return `/* MANUAL_REWRITE_REQUIRED: no SSJS equivalent for ${fnName} */ ${fnName}(`;
+        return `/* MANUAL_REWRITE_REQUIRED: no SSJS equivalent for ${functionName} */ ${functionName}(`;
     });
     // Strip @ from variable references
     result = stripAmpVars(result);
@@ -698,6 +750,335 @@ function ampCondToSsjs(cond) {
 export function stripAmpVars(expr) {
     return expr.replaceAll(/@(\w+)/g, '$1');
 }
+// ---------------------------------------------------------------------------
+// AMPscript ↔ MCN Handlebars conversion
+// ---------------------------------------------------------------------------
+/**
+ * Distinct MANUAL_REWRITE note for Category C functions (`mcnHandlebarsGap`).
+ * Must be visibly different from the Category B note so consumers can tell a
+ * documented-but-broken function apart from one with no counterpart at all.
+ */
+export const HBS_GAP_NOTE = 'documented as supported in Marketing Cloud Next but currently fails at runtime — no Handlebars helper exists yet';
+/**
+ * Fold a single character into the argument-splitting accumulator state.
+ * @param state - Mutable accumulator carried across characters.
+ * @param ch - The current character.
+ */
+function foldArgumentChar(state, ch) {
+    if (state.quote) {
+        state.current += ch;
+        if (ch === state.quote)
+            state.quote = null;
+        return;
+    }
+    switch (ch) {
+        case '"':
+        case "'": {
+            state.quote = ch;
+            state.current += ch;
+            break;
+        }
+        case '(':
+        case '[': {
+            state.depth++;
+            state.current += ch;
+            break;
+        }
+        case ')':
+        case ']': {
+            state.depth--;
+            state.current += ch;
+            break;
+        }
+        default: {
+            if (ch === ',' && state.depth === 0) {
+                state.args.push(state.current.trim());
+                state.current = '';
+            }
+            else {
+                state.current += ch;
+            }
+        }
+    }
+}
+function splitArguments(argsStr) {
+    if (!argsStr.trim())
+        return [];
+    const state = { depth: 0, current: '', quote: null, args: [] };
+    for (const ch of argsStr) {
+        foldArgumentChar(state, ch);
+    }
+    if (state.current.trim())
+        state.args.push(state.current.trim());
+    return state.args;
+}
+/**
+ * Convert a single AMPscript call argument to its Handlebars form: string and
+ * numeric literals pass through unchanged; `@var` references lose the `@`.
+ * @param arg - A single AMPscript argument.
+ * @returns {string} The Handlebars argument.
+ */
+function ampArgumentToHbs(arg) {
+    const t = arg.trim();
+    if (/^["']/.test(t))
+        return t;
+    return stripAmpVars(t);
+}
+/**
+ * Convert a single Handlebars argument to its AMPscript form: string/number/
+ * boolean literals pass through; bare identifiers become `@var` references;
+ * dotted paths are returned unchanged (caller decides how to flag them).
+ * @param arg - A single Handlebars argument.
+ * @returns {string} The AMPscript argument.
+ */
+function hbsArgumentToAmp(arg) {
+    const t = arg.trim();
+    if (/^["']/.test(t))
+        return t;
+    if (/^-?\d/.test(t))
+        return t;
+    if (/^(true|false|null)$/i.test(t))
+        return t;
+    if (t.startsWith('@'))
+        return t;
+    if (/^[A-Za-z_]\w*$/.test(t))
+        return `@${t}`;
+    return t;
+}
+/**
+ * Convert the inner text of a single AMPscript inline expression (`%%=…=%%`)
+ * to Handlebars, classifying function calls by the three conversion categories.
+ * @param inner - The expression between `%%=` and `=%%` (already trimmed).
+ * @param lineNum - Source line number for change/flag tracking.
+ * @param changes - Mutable change log.
+ * @param flaggedSections - Mutable flagged-section log.
+ * @returns {string} The Handlebars replacement string.
+ */
+function convertInlineAmpToHbs(inner, lineNum, changes, flaggedSections) {
+    // v(@x) / v(x) → {{x}}
+    const vMatch = /^v\s*\(\s*@?([A-Za-z_]\w*)\s*\)$/i.exec(inner);
+    if (vMatch) {
+        changes.push({ line: lineNum, description: `%%=v(@${vMatch[1]})=%% → {{${vMatch[1]}}}` });
+        return `{{${vMatch[1]}}}`;
+    }
+    // Bare @var / var → {{var}}
+    const variableMatch = /^@?([A-Za-z_]\w*)$/.exec(inner);
+    if (variableMatch) {
+        changes.push({ line: lineNum, description: `%%=${inner}=%% → {{${variableMatch[1]}}}` });
+        return `{{${variableMatch[1]}}}`;
+    }
+    // FunctionName(args)
+    const functionMatch = /^([A-Za-z_]\w*)\s*\(([\s\S]*)\)$/.exec(inner);
+    if (functionMatch) {
+        const functionName = functionMatch[1];
+        const key = functionName.toLowerCase();
+        const hbsArguments = splitArguments(functionMatch[2]).map((a) => ampArgumentToHbs(a));
+        // Category A — mapped helper.
+        const helper = AMP_TO_HANDLEBARS[key];
+        if (helper) {
+            changes.push({
+                line: lineNum,
+                description: `%%=${functionName}(…)=%% → {{${helper} …}}`,
+            });
+            return `{{${helper}${hbsArguments.length > 0 ? ' ' + hbsArguments.join(' ') : ''}}}`;
+        }
+        // Category C — mcnHandlebarsGap (distinct note from Category B).
+        if (AMP_MCN_HANDLEBARS_GAP.has(key)) {
+            flaggedSections.push({
+                line: lineNum,
+                code: `%%=${inner}=%%`,
+                reason: `${functionName} is ${HBS_GAP_NOTE}`,
+            });
+            return `{{!-- MANUAL_REWRITE_REQUIRED: ${functionName} is ${HBS_GAP_NOTE} --}}`;
+        }
+        // Category B — no Handlebars counterpart.
+        flaggedSections.push({
+            line: lineNum,
+            code: `%%=${inner}=%%`,
+            reason: `AMPscript function '${functionName}' has no Handlebars equivalent`,
+        });
+        return `{{!-- MANUAL_REWRITE_REQUIRED: AMPscript function '${functionName}' has no Handlebars equivalent --}}`;
+    }
+    // Anything else (complex expression).
+    flaggedSections.push({
+        line: lineNum,
+        code: `%%=${inner}=%%`,
+        reason: 'complex AMPscript expression has no direct Handlebars form',
+    });
+    return `{{!-- MANUAL_REWRITE_REQUIRED: ${inner} --}}`;
+}
+/**
+ * Convert AMPscript to MCN Handlebars using deterministic, data-driven rules.
+ *
+ * Inline expressions (`%%=Fn(args)=%%`, `%%=v(@x)=%%`, `%%var%%`) are mapped via
+ * the three conversion categories built from ampscript-data's
+ * `handlebarsEquivalent` / `mcnHandlebarsGap` fields:
+ * - **A** — mapped helper → `{{helper …}}`
+ * - **B** — no counterpart → `{{!-- MANUAL_REWRITE_REQUIRED … --}}`
+ * - **C** — `mcnHandlebarsGap` → `{{!-- MANUAL_REWRITE_REQUIRED … (distinct note) --}}`
+ *
+ * Procedural AMPscript blocks (`%%[ … ]%%`, `SET`/`VAR`/`IF`/`FOR`) have no
+ * Handlebars counterpart (Handlebars cannot assign variables or run imperative
+ * control flow) and are flagged MANUAL_REWRITE_REQUIRED.
+ * @param code - AMPscript source code (may include HTML context).
+ * @returns {ConversionResult} Converted Handlebars, change log, and flagged sections.
+ */
+export function ampscriptToHandlebars(code) {
+    const changes = [];
+    const flaggedSections = [];
+    const lines = code.split('\n');
+    const outputLines = [];
+    let isInBlock = false;
+    for (const [index, line] of lines.entries()) {
+        const lineNumber = index + 1;
+        const trimmed = line.trim();
+        // Track multi-line %%[ … ]%% blocks — flag the whole block once.
+        if (isInBlock) {
+            if (/\]%%/.test(line))
+                isInBlock = false;
+            continue;
+        }
+        if (/%%\[/.test(line)) {
+            if (!/\]%%/.test(line))
+                isInBlock = true;
+            outputLines.push('{{!-- MANUAL_REWRITE_REQUIRED: AMPscript block (SET/VAR/IF/FOR) has no Handlebars equivalent — Handlebars cannot assign variables or run imperative control flow --}}');
+            flaggedSections.push({
+                line: lineNumber,
+                code: trimmed.slice(0, 80),
+                reason: 'AMPscript procedural block has no Handlebars counterpart',
+            });
+            continue;
+        }
+        // Convert inline expressions on this line.
+        const converted = line
+            .replaceAll(/%%=\s*([\s\S]*?)\s*=%%/g, (_full, raw) => convertInlineAmpToHbs(raw.trim(), lineNumber, changes, flaggedSections))
+            .replaceAll(/%%([A-Za-z_]\w*)%%/g, (_full, v) => {
+            changes.push({ line: lineNumber, description: `%%${v}%% → {{${v}}}` });
+            return `{{${v}}}`;
+        });
+        outputLines.push(converted);
+    }
+    return { convertedCode: outputLines.join('\n'), changes, flaggedSections };
+}
+/**
+ * Convert MCN Handlebars to AMPscript using deterministic, data-driven rules.
+ *
+ * Inline helper calls (`{{helper args}}`) whose helper maps back to an AMPscript
+ * function (via HANDLEBARS_TO_AMP) become `%%=Fn(args)=%%`; bare variables
+ * (`{{name}}`) become `%%=v(@name)=%%`. Block helpers (`{{#each}}`…), partials
+ * (`{{> …}}`), dotted binding paths, and unknown helpers are flagged
+ * MANUAL_REWRITE_REQUIRED.
+ * @param code - Handlebars source code (may include HTML context).
+ * @returns {ConversionResult} Converted AMPscript, change log, and flagged sections.
+ */
+export function handlebarsToAmpscript(code) {
+    const changes = [];
+    const flaggedSections = [];
+    let lineCursor = 1;
+    let lastIndex = 0;
+    const convertedCode = code.replaceAll(/\{\{([\s\S]*?)\}\}/g, (full, raw, offset) => {
+        lineCursor += countNewlines(code.slice(lastIndex, offset));
+        lastIndex = offset;
+        const lineNumber = lineCursor;
+        const inner = raw.trim();
+        // Comments — preserve as an AMPscript comment.
+        if (inner.startsWith('!')) {
+            return full;
+        }
+        // Block helpers / partials / closing tags — no deterministic AMPscript form.
+        if (/^[#/>]/.test(inner)) {
+            flaggedSections.push({
+                line: lineNumber,
+                code: full,
+                reason: 'Handlebars block helper / partial has no direct AMPscript equivalent',
+            });
+            return `%%-- MANUAL_REWRITE_REQUIRED: ${full} --%%`;
+        }
+        // Strip a leading no-escape ampersand: {{& x}}.
+        const body = inner.replace(/^&\s*/, '');
+        // Helper with arguments: {{helper arg1 arg2 …}}
+        const functionMatch = /^([A-Za-z_]\w*)\s+(.+)$/.exec(body);
+        if (functionMatch) {
+            const helperName = functionMatch[1];
+            const key = helperName.toLowerCase();
+            const ampName = HANDLEBARS_TO_AMP[key];
+            const ampArguments = splitArguments(functionMatch[2]).map((a) => hbsArgumentToAmp(a));
+            if (ampName) {
+                changes.push({
+                    line: lineNumber,
+                    description: `{{${helperName} …}} → %%=${ampName}(…)=%%`,
+                });
+                return `%%=${ampName}(${ampArguments.join(', ')})=%%`;
+            }
+            flaggedSections.push({
+                line: lineNumber,
+                code: full,
+                reason: `Handlebars helper '${helperName}' has no AMPscript equivalent`,
+            });
+            return `%%-- MANUAL_REWRITE_REQUIRED: Handlebars helper '${helperName}' has no AMPscript equivalent --%%`;
+        }
+        // Bare single identifier: {{name}} → %%=v(@name)=%%
+        const bareMatch = /^([A-Za-z_]\w*)$/.exec(body);
+        if (bareMatch) {
+            changes.push({
+                line: lineNumber,
+                description: `{{${bareMatch[1]}}} → %%=v(@${bareMatch[1]})=%%`,
+            });
+            return `%%=v(@${bareMatch[1]})=%%`;
+        }
+        // Dotted binding path or other expression — context-specific.
+        flaggedSections.push({
+            line: lineNumber,
+            code: full,
+            reason: 'Handlebars binding path requires context-specific AMPscript mapping',
+        });
+        return `%%-- MANUAL_REWRITE_REQUIRED: ${full} --%%`;
+    });
+    return { convertedCode, changes, flaggedSections };
+}
+/**
+ * Count newline characters in a string (helper for line tracking in
+ * handlebarsToAmpscript).
+ * @param s - Input string.
+ * @returns {number} Number of `\n` characters.
+ */
+function countNewlines(s) {
+    let n = 0;
+    for (const ch of s) {
+        if (ch === '\n')
+            n++;
+    }
+    return n;
+}
+/**
+ * Convert SSJS to MCN Handlebars deterministically via a two-step chain:
+ * SSJS → AMPscript (`ssjsToAmpscript`) → Handlebars (`ampscriptToHandlebars`).
+ *
+ * Because Handlebars is declarative, most imperative SSJS has no Handlebars
+ * counterpart and is conservatively flagged MANUAL_REWRITE_REQUIRED; inline
+ * `Platform.Function.X(…)` calls that map through AMPscript to a Handlebars
+ * helper are converted.
+ * @param code - SSJS source code (may include `<script runat="server">` tags).
+ * @returns {ConversionResult} Converted Handlebars, combined change log, and flagged sections.
+ */
+export function ssjsToHandlebars(code) {
+    const toAmp = ssjsToAmpscript(code);
+    const toHbs = ampscriptToHandlebars(toAmp.convertedCode);
+    return {
+        convertedCode: toHbs.convertedCode,
+        changes: [
+            ...toAmp.changes.map((c) => ({
+                line: c.line,
+                description: `[SSJS→AMPscript] ${c.description}`,
+            })),
+            ...toHbs.changes.map((c) => ({
+                line: c.line,
+                description: `[AMPscript→Handlebars] ${c.description}`,
+            })),
+        ],
+        flaggedSections: [...toAmp.flaggedSections, ...toHbs.flaggedSections],
+    };
+}
 /**
  * Rewrite AMPscript code to be compatible with Marketing Cloud Next.
  *
@@ -717,15 +1098,15 @@ export function rewriteAmpForMcn(code, options) {
     let rewrittenCode = code;
     // 1. Remove StringToDate() wrapper inside FormatDate() first argument
     // FormatDate(StringToDate(x), fmt) → FormatDate(x, fmt)
-    const strToDatePattern = /FormatDate\s*\(\s*StringToDate\s*\(([^)]+)\)\s*,/gi;
-    if (strToDatePattern.test(rewrittenCode)) {
+    const stringToDatePattern = /FormatDate\s*\(\s*StringToDate\s*\(([^)]+)\)\s*,/gi;
+    if (stringToDatePattern.test(rewrittenCode)) {
         rewrittenCode = rewrittenCode.replaceAll(/FormatDate\s*\(\s*StringToDate\s*\(([^)]+)\)\s*,/gi, 'FormatDate($1,');
         // Find affected lines for change tracking
         const lines = code.split('\n');
-        for (const [i, line] of lines.entries()) {
+        for (const [index, line] of lines.entries()) {
             if (/FormatDate\s*\(\s*StringToDate\s*\(/i.test(line)) {
                 changes.push({
-                    line: i + 1,
+                    line: index + 1,
                     type: 'rewritten',
                     description: 'Removed StringToDate() wrapper: FormatDate(StringToDate(x), fmt) → FormatDate(x, fmt)',
                 });
@@ -733,104 +1114,102 @@ export function rewriteAmpForMcn(code, options) {
         }
     }
     // 2. Convert .NET format strings to Java SimpleDateFormat in FormatDate() calls
-    rewrittenCode = rewrittenCode.replaceAll(/FormatDate\s*\(\s*([^,]+),\s*"([^"]+)"\s*\)/gi, (match, arg1, formatStr) => {
-        let newFormat = formatStr;
-        let changed = false;
-        let hasShorthand = false;
+    rewrittenCode = rewrittenCode.replaceAll(/FormatDate\s*\(\s*([^,]+),\s*"([^"]+)"\s*\)/gi, (match, argument1, formatString) => {
         // Check for standard shorthands
-        for (const shorthand of DOTNET_STANDARD_SHORTHANDS) {
-            if (new RegExp(`^${shorthand}$`).test(formatStr.trim())) {
-                hasShorthand = true;
-            }
-        }
+        const trimmedFormat = formatString.trim();
+        const hasShorthand = [...DOTNET_STANDARD_SHORTHANDS].some((shorthand) => new RegExp(`^${shorthand}$`).test(trimmedFormat));
         if (hasShorthand) {
             // Annotate with comment about needing explicit format
-            return `FormatDate(${arg1}, "/* MANUAL_REWRITE_REQUIRED: Convert .NET standard shorthand '${formatStr}' to explicit Java SimpleDateFormat pattern */"${formatStr}")`;
+            return `FormatDate(${argument1}, "/* MANUAL_REWRITE_REQUIRED: Convert .NET standard shorthand '${formatString}' to explicit Java SimpleDateFormat pattern */"${formatString}")`;
         }
+        let newFormat = formatString;
+        let isChanged = false;
         // Apply .NET → Java replacements
         for (const [pattern, replacement] of DOTNET_TO_JAVA_FORMAT_REPLACEMENTS) {
             const before = newFormat;
-            newFormat = newFormat.replace(pattern, replacement);
+            newFormat = newFormat.replace(pattern, () => replacement);
             if (newFormat !== before) {
-                changed = true;
+                isChanged = true;
             }
         }
-        if (changed) {
-            return `FormatDate(${arg1}, "${newFormat}")`;
+        if (isChanged) {
+            return `FormatDate(${argument1}, "${newFormat}")`;
         }
         return match;
     });
     // Track format string changes
     const codeLines = code.split('\n');
     const rewrittenLines = rewrittenCode.split('\n');
-    for (const [i, codeLine] of codeLines.entries()) {
-        if (codeLine !== rewrittenLines[i] && /FormatDate/i.test(codeLine)) {
+    for (const [index, codeLine] of codeLines.entries()) {
+        if (codeLine !== rewrittenLines[index] && /FormatDate/i.test(codeLine)) {
             changes.push({
-                line: i + 1,
+                line: index + 1,
                 type: 'rewritten',
                 description: `Converted .NET format string to Java SimpleDateFormat in FormatDate()`,
             });
         }
     }
     // 3. Annotate Lookup() calls with odd argument counts
-    rewrittenCode = rewrittenCode.replaceAll(/\bLookup\s*\(([^)]+)\)/gi, (match, argsStr) => {
-        const argCount = countArgs(argsStr);
+    rewrittenCode = rewrittenCode.replaceAll(/\bLookup\s*\(([^)]+)\)/gi, (match, argumentsString) => {
+        const argumentCount = countArgs(argumentsString);
         // Lookup takes: DE, returnCol, [searchCol, searchVal, ...]
         // Min 2 args, then pairs after that → should be even number > 2 or exactly 2
         // Odd count after first 2 = problem
-        if (argCount >= 3 && (argCount - 2) % 2 !== 0) {
-            return `${match} %%-- MCN NOTE: Lookup() requires search arguments in column/value pairs (even count after DE and return column). Current arg count (${argCount}) may cause an error in MCN. --%% `;
+        if (argumentCount >= 3 && (argumentCount - 2) % 2 !== 0) {
+            return `${match} %%-- MCN NOTE: Lookup() requires search arguments in column/value pairs (even count after DE and return column). Current arg count (${argumentCount}) may cause an error in MCN. --%% `;
         }
         return match;
     });
     // 4. Mark MCE-only function calls with annotation
     // Find all function calls and mark unsupported ones
-    const funcCallPattern = /\b([A-Z][A-Za-z]+)\s*\(/g;
-    let funcMatch;
+    const functionCallPattern = /\b([A-Z][A-Za-z]+)\s*\(/g;
+    let functionMatch;
     const seenUnsupported = new Set();
-    while ((funcMatch = funcCallPattern.exec(code)) !== null) {
-        const fnName = funcMatch[1];
-        if (!isMcnSupportedFn(fnName) && fnName.length > 1) {
-            seenUnsupported.add(fnName);
+    while ((functionMatch = functionCallPattern.exec(code)) !== null) {
+        const functionName = functionMatch[1];
+        if (!isMcnSupportedFn(functionName) && functionName.length > 1) {
+            seenUnsupported.add(functionName);
         }
     }
-    for (const fnName of seenUnsupported) {
-        const mcnNotes = getMcnNotesFn(fnName);
-        const annotationPattern = new RegExp(String.raw `\b${fnName}\s*\(`, 'gi');
+    for (const functionName of seenUnsupported) {
+        const mcnNotes = getMcnNotesFn(functionName);
+        const annotationPattern = new RegExp(String.raw `\b${functionName}\s*\(`, 'gi');
         rewrittenCode = rewrittenCode.replace(annotationPattern, (m) => {
-            return `%%-- NOT SUPPORTED IN MCN: ${fnName}${mcnNotes ? ` — ${mcnNotes}` : ''} --%%\n${m}`;
+            return `%%-- NOT SUPPORTED IN MCN: ${functionName}${mcnNotes ? ` — ${mcnNotes}` : ''} --%%\n${m}`;
         });
         // Find lines for tracking
-        for (const [i, codeLine] of codeLines.entries()) {
-            if (new RegExp(String.raw `\b${fnName}\s*\(`, 'i').test(codeLine)) {
-                changes.push({
-                    line: i + 1,
-                    type: 'annotated',
-                    description: `${fnName}() is not supported in Marketing Cloud Next`,
-                });
-                nonMigratableItems.push({
-                    line: i + 1,
-                    code: codeLine.trim(),
-                    reason: `${fnName}() is not available in Marketing Cloud Next`,
-                });
-            }
+        const linePattern = new RegExp(String.raw `\b${functionName}\s*\(`, 'i');
+        const matchingLines = codeLines
+            .map((codeLine, index) => ({ codeLine, index }))
+            .filter(({ codeLine }) => linePattern.test(codeLine));
+        for (const { codeLine, index } of matchingLines) {
+            changes.push({
+                line: index + 1,
+                type: 'annotated',
+                description: `${functionName}() is not supported in Marketing Cloud Next`,
+            });
+            nonMigratableItems.push({
+                line: index + 1,
+                code: codeLine.trim(),
+                reason: `${functionName}() is not available in Marketing Cloud Next`,
+            });
         }
     }
     // 5. Check for CloudPages functions
-    const cloudFnPattern = /\b(CloudPagesURL|RequestParameter|QueryParameter|Redirect|MicrositeURL)\s*\(/gi;
+    const cloudFunctionPattern = /\b(CloudPagesURL|RequestParameter|QueryParameter|Redirect|MicrositeURL)\s*\(/gi;
     let cloudMatch;
-    while ((cloudMatch = cloudFnPattern.exec(code)) !== null) {
-        const fnName = cloudMatch[1];
-        const lineNum = code.slice(0, cloudMatch.index).split('\n').length;
+    while ((cloudMatch = cloudFunctionPattern.exec(code)) !== null) {
+        const functionName = cloudMatch[1];
+        const lineNumber = code.slice(0, cloudMatch.index).split('\n').length;
         nonMigratableItems.push({
-            line: lineNum,
-            code: codeLines[lineNum - 1]?.trim() ?? fnName,
-            reason: `${fnName}() is a CloudPages-specific function and cannot run in Marketing Cloud Next`,
+            line: lineNumber,
+            code: codeLines[lineNumber - 1]?.trim() ?? functionName,
+            reason: `${functionName}() is a CloudPages-specific function and cannot run in Marketing Cloud Next`,
         });
     }
     // Assess difficulty
     const hasNotMigratable = nonMigratableItems.some((item) => item.reason.includes('CloudPages') || item.reason.includes('NOT SUPPORTED'));
-    const hasMcnNotes = Array.from(seenUnsupported).some((fn) => getMcnNotesFn(fn) !== null) ||
+    const hasMcnNotes = Array.from(seenUnsupported).some((function_) => getMcnNotesFn(function_) !== null) ||
         /FormatDate|StringToDate|Lookup/i.test(code);
     const hasSsjs = /<script[^>]+runat/i.test(code);
     let difficulty;