c-next 0.2.3 → 0.2.5

package/dist/index.js

@@ -10,7 +10,7 @@ import { hideBin } from "yargs/helpers";
 // package.json
 var package_default = {
   name: "c-next",
-  version: "0.2.3",
+  version: "0.2.5",
   description: "A safer C for embedded systems development. Transpiles to clean, readable C.",
   packageManager: "npm@11.9.0",
   type: "module",
@@ -32,6 +32,8 @@ var package_default = {
     "test:cli": "node scripts/test-cli.js",
     "test:q": "tsx scripts/test.ts -q",
     "test:update": "tsx scripts/test.ts --update",
+    "integration:transpile": "tsx scripts/test.ts --transpile-only",
+    "integration:execute": "tsx scripts/test.ts --execute-only",
     analyze: "./scripts/static-analysis.sh",
     clean: "rm -rf dist src/transpiler/logic/parser/grammar src/transpiler/logic/parser/c/grammar src/transpiler/logic/parser/cpp/grammar",
     "prettier:check": "prettier --check .",
@@ -110764,6 +110766,12 @@ var CodeGenState = class {
   static callbackTypes = /* @__PURE__ */ new Map();
   /** Callback field types: "Struct.field" -> callbackTypeName */
   static callbackFieldTypes = /* @__PURE__ */ new Map();
+  /**
+   * Functions that are assigned to C callback typedefs.
+   * Maps function name -> typedef name (e.g., "my_flush" -> "flush_cb_t")
+   * Issue #895: We need the typedef name to look up parameter types.
+   */
+  static callbackCompatibleFunctions = /* @__PURE__ */ new Map();
   // ===========================================================================
   // PASS-BY-VALUE ANALYSIS (Issue #269)
   // ===========================================================================
@@ -111131,6 +111139,20 @@ var CodeGenState = class {
   static getCallbackType(name) {
     return this.callbackTypes.get(name);
   }
+  /**
+   * Issue #895: Get the typedef type string for a C typedef by name.
+   * Used to look up function pointer typedef signatures for callback-compatible functions.
+   *
+   * @param typedefName - Name of the typedef (e.g., "flush_cb_t")
+   * @returns The type string (e.g., "void (*)(widget_t *, const rect_t *, uint8_t *)") or undefined
+   */
+  static getTypedefType(typedefName) {
+    const symbol = this.symbolTable.getCSymbol(typedefName);
+    if (symbol?.kind === "type") {
+      return symbol.type;
+    }
+    return void 0;
+  }
   /**
    * Check if a type name is a known C-Next function.
    */
@@ -112904,7 +112926,7 @@ var TYPE_RANGES = {
 };
 var TYPE_RANGES_default = TYPE_RANGES;
 
-// src/transpiler/output/codegen/utils/ExpressionUnwrapper.ts
+// src/utils/ExpressionUnwrapper.ts
 var ExpressionUnwrapper = class {
   /**
    * Navigate from ExpressionContext to ShiftExpressionContext.
@@ -114074,14 +114096,14 @@ var TypeValidator = class _TypeValidator {
     }
   }
   // ========================================================================
-  // Do-While Validation (ADR-027)
+  // Condition Boolean Validation (ADR-027, Issue #884)
   // ========================================================================
-  static validateDoWhileCondition(ctx) {
+  static validateConditionIsBoolean(ctx, conditionType) {
     const ternaryExpr = ctx.ternaryExpression();
     const orExprs = ternaryExpr.orExpression();
     if (orExprs.length !== 1) {
       throw new Error(
-        `Error E0701: do-while condition must be a boolean expression, not a ternary (MISRA C:2012 Rule 14.4)`
+        `Error E0701: ${conditionType} condition must be a boolean expression, not a ternary (MISRA C:2012 Rule 14.4)`
       );
     }
     const orExpr = orExprs[0];
@@ -114092,7 +114114,7 @@ var TypeValidator = class _TypeValidator {
     const andExpr = orExpr.andExpression(0);
     if (!andExpr) {
       throw new Error(
-        `Error E0701: do-while condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)`
+        `Error E0701: ${conditionType} condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)`
       );
     }
     if (andExpr.equalityExpression().length > 1) {
@@ -114101,7 +114123,7 @@ var TypeValidator = class _TypeValidator {
     const equalityExpr = andExpr.equalityExpression(0);
     if (!equalityExpr) {
       throw new Error(
-        `Error E0701: do-while condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)`
+        `Error E0701: ${conditionType} condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)`
       );
     }
     if (equalityExpr.relationalExpression().length > 1) {
@@ -114110,7 +114132,7 @@ var TypeValidator = class _TypeValidator {
     const relationalExpr = equalityExpr.relationalExpression(0);
     if (!relationalExpr) {
       throw new Error(
-        `Error E0701: do-while condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)`
+        `Error E0701: ${conditionType} condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)`
       );
     }
     if (relationalExpr.bitwiseOrExpression().length > 1) {
@@ -114121,7 +114143,7 @@ var TypeValidator = class _TypeValidator {
       return;
     }
     throw new Error(
-      `Error E0701: do-while condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)
+      `Error E0701: ${conditionType} condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)
   help: use explicit comparison: ${text} > 0 or ${text} != 0`
     );
   }
@@ -115742,6 +115764,7 @@ var generatePostfixExpression = (ctx, input, state, orchestrator) => {
   const rootIdentifier = primary.IDENTIFIER()?.getText();
   const paramInfo = rootIdentifier ? state.currentParameters.get(rootIdentifier) : null;
   const isStructParam = paramInfo?.isStruct ?? false;
+  const forcePointerSemantics = paramInfo?.forcePointerSemantics ?? false;
   const hasSubscriptOps = ops.some((op) => op.expression().length > 0);
   const isNonArrayParamWithSubscript = paramInfo && !paramInfo.isArray && !paramInfo.isStruct && hasSubscriptOps;
   let result;
@@ -115762,6 +115785,7 @@ var generatePostfixExpression = (ctx, input, state, orchestrator) => {
   const postfixCtx = {
     rootIdentifier,
     isStructParam,
+    forcePointerSemantics,
     input,
     state,
     orchestrator,
@@ -115853,6 +115877,7 @@ var handleMemberOp = (memberName, tracking, ctx) => {
       memberName,
       rootIdentifier: ctx.rootIdentifier,
       isStructParam: ctx.isStructParam,
+      forcePointerSemantics: ctx.forcePointerSemantics,
       isGlobalAccess: tracking.isGlobalAccess,
       isCppAccessChain: tracking.isCppAccessChain,
       currentStructType: tracking.currentStructType,
@@ -116587,7 +116612,7 @@ var tryStructParamAccess = (ctx, orchestrator) => {
   if (!ctx.isStructParam || ctx.result !== ctx.rootIdentifier) {
     return null;
   }
-  const structParamSep = memberAccessChain_default.getStructParamSeparator({
+  const structParamSep = ctx.forcePointerSemantics ? "->" : memberAccessChain_default.getStructParamSeparator({
     cppMode: orchestrator.isCppMode()
   });
   const output = initializeMemberOutput(ctx);
@@ -116940,6 +116965,7 @@ var generateIf = (node, _input, _state, orchestrator) => {
   }
   const cacheDecls = orchestrator.setupLengthCache(lengthCounts);
   orchestrator.validateConditionNoFunctionCall(node.expression(), "if");
+  orchestrator.validateConditionIsBoolean(node.expression(), "if");
   const condition = orchestrator.generateExpression(node.expression());
   const conditionTemps = orchestrator.flushPendingTempDeclarations();
   const thenBranch = orchestrator.generateStatement(thenStmt);
@@ -116960,6 +116986,7 @@ var generateIf = (node, _input, _state, orchestrator) => {
 var generateWhile = (node, _input, _state, orchestrator) => {
   const effects = [];
   orchestrator.validateConditionNoFunctionCall(node.expression(), "while");
+  orchestrator.validateConditionIsBoolean(node.expression(), "while");
   const condition = orchestrator.generateExpression(node.expression());
   const conditionTemps = orchestrator.flushPendingTempDeclarations();
   const body = orchestrator.generateStatement(node.statement());
@@ -116971,8 +116998,8 @@ var generateWhile = (node, _input, _state, orchestrator) => {
 };
 var generateDoWhile = (node, _input, _state, orchestrator) => {
   const effects = [];
-  orchestrator.validateDoWhileCondition(node.expression());
   orchestrator.validateConditionNoFunctionCall(node.expression(), "do-while");
+  orchestrator.validateConditionIsBoolean(node.expression(), "do-while");
   const body = orchestrator.generateBlock(node.block());
   const condition = orchestrator.generateExpression(node.expression());
   const conditionTemps = orchestrator.flushPendingTempDeclarations();
@@ -117037,6 +117064,7 @@ var generateFor = (node, input, state, orchestrator) => {
   let condition = "";
   if (node.expression()) {
     orchestrator.validateConditionNoFunctionCall(node.expression(), "for");
+    orchestrator.validateConditionIsBoolean(node.expression(), "for");
     condition = orchestrator.generateExpression(node.expression());
   }
   const conditionTemps = orchestrator.flushPendingTempDeclarations();
@@ -124789,7 +124817,16 @@ var MemberSeparatorResolver = class _MemberSeparatorResolver {
   /**
    * Build the separator context for a member access chain
    */
-  static buildContext(firstId, hasGlobal, hasThis, currentScope, isStructParam, deps, isCppAccess) {
+  static buildContext(input, deps) {
+    const {
+      firstId,
+      hasGlobal,
+      hasThis,
+      currentScope,
+      isStructParam,
+      isCppAccess,
+      forcePointerSemantics
+    } = input;
     const isCrossScope = hasGlobal && (deps.isKnownScope(firstId) || deps.isKnownRegister(firstId));
     const scopedRegName = hasThis && currentScope ? `${currentScope}_${firstId}` : null;
     const isScopedRegister = scopedRegName !== null && deps.isKnownRegister(scopedRegName);
@@ -124799,7 +124836,8 @@ var MemberSeparatorResolver = class _MemberSeparatorResolver {
       isStructParam,
       isCppAccess,
       scopedRegName,
-      isScopedRegister
+      isScopedRegister,
+      forcePointerSemantics
     };
   }
   /**
@@ -124810,6 +124848,9 @@ var MemberSeparatorResolver = class _MemberSeparatorResolver {
       return "::";
     }
     if (ctx.isStructParam) {
+      if (ctx.forcePointerSemantics) {
+        return "->";
+      }
       return deps.getStructParamSeparator();
     }
     if (ctx.isCrossScope) {
@@ -124870,6 +124911,9 @@ var ParameterDereferenceResolver = class _ParameterDereferenceResolver {
    * Determine if a parameter should be passed by value (no dereference needed)
    */
   static isPassByValue(paramInfo, deps) {
+    if (paramInfo.isCallbackPointerPrimitive) {
+      return false;
+    }
     if (paramInfo.isCallback) {
       return true;
     }
@@ -124908,6 +124952,9 @@ var ParameterDereferenceResolver = class _ParameterDereferenceResolver {
     if (_ParameterDereferenceResolver.isPassByValue(paramInfo, deps)) {
       return id;
     }
+    if (paramInfo.forcePointerSemantics) {
+      return `(*${id})`;
+    }
     return deps.maybeDereference(id);
   }
 };
@@ -125450,6 +125497,137 @@ var CastValidator = class _CastValidator {
 };
 var CastValidator_default = CastValidator;
 
+// src/transpiler/output/codegen/helpers/TypedefParamParser.ts
+var TypedefParamParser = class _TypedefParamParser {
+  /**
+   * Parse a function pointer typedef type string.
+   *
+   * @param typedefType - The type string, e.g., "void (*)(widget_t *, const rect_t *, uint8_t *)"
+   * @returns Parsed result with return type and parameters, or null if parsing fails
+   */
+  static parse(typedefType) {
+    const funcPtrIndex = typedefType.indexOf("(*)");
+    if (funcPtrIndex === -1) {
+      return null;
+    }
+    const returnType = typedefType.substring(0, funcPtrIndex).trim();
+    const afterFuncPtr = typedefType.substring(funcPtrIndex + 3).trim();
+    if (!afterFuncPtr.startsWith("(")) {
+      return null;
+    }
+    const paramsStr = _TypedefParamParser.extractParenContent(afterFuncPtr);
+    if (paramsStr === null) {
+      return null;
+    }
+    if (!paramsStr || paramsStr === "void") {
+      return { returnType, params: [] };
+    }
+    const paramStrings = _TypedefParamParser.splitParams(paramsStr);
+    const params = paramStrings.map((p) => _TypedefParamParser.parseParam(p));
+    return { returnType, params };
+  }
+  /**
+   * Extract content between matching parentheses, handling arbitrary nesting.
+   * @param str - String starting with '('
+   * @returns Content between outer parens, or null if no match
+   */
+  static extractParenContent(str) {
+    if (!str.startsWith("(")) {
+      return null;
+    }
+    let depth = 0;
+    for (let i = 0; i < str.length; i++) {
+      if (str[i] === "(") {
+        depth++;
+      } else if (str[i] === ")") {
+        depth--;
+        if (depth === 0) {
+          return str.substring(1, i);
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Split parameter string by commas, respecting nested parentheses.
+   */
+  static splitParams(paramsStr) {
+    const params = [];
+    let current = "";
+    let depth = 0;
+    for (const char of paramsStr) {
+      if (char === "(") {
+        depth++;
+        current += char;
+      } else if (char === ")") {
+        depth--;
+        current += char;
+      } else if (char === "," && depth === 0) {
+        params.push(current.trim());
+        current = "";
+      } else {
+        current += char;
+      }
+    }
+    if (current.trim()) {
+      params.push(current.trim());
+    }
+    return params;
+  }
+  /**
+   * Parse a single parameter type string.
+   */
+  static parseParam(paramStr) {
+    const trimmed = paramStr.trim();
+    const isPointer = trimmed.includes("*");
+    const isConst = /\bconst\b/.test(trimmed) || trimmed.startsWith("const");
+    let baseType = trimmed.replaceAll(/\bconst\b/g, "").replace(/^const/, "").replaceAll("*", "").replaceAll(/\s+/g, " ").trim();
+    if (baseType.includes(" ")) {
+      baseType = baseType.replace(/\s+\w+$/, "");
+    }
+    if (baseType.startsWith("struct ")) {
+      baseType = baseType.substring(7);
+    }
+    return {
+      type: trimmed,
+      isPointer,
+      isConst,
+      baseType
+    };
+  }
+  /**
+   * Get the parameter info at a given index, or null if not found.
+   */
+  static getParamAt(typedefType, paramIndex) {
+    const parsed = _TypedefParamParser.parse(typedefType);
+    if (!parsed || paramIndex >= parsed.params.length) {
+      return null;
+    }
+    return parsed.params[paramIndex];
+  }
+  /**
+   * Check if a parameter at a given index should be a pointer based on the typedef.
+   *
+   * @param typedefType - The typedef type string
+   * @param paramIndex - The parameter index (0-based)
+   * @returns true if the param should be a pointer, false for value, null if unknown
+   */
+  static shouldBePointer(typedefType, paramIndex) {
+    return _TypedefParamParser.getParamAt(typedefType, paramIndex)?.isPointer ?? null;
+  }
+  /**
+   * Check if a parameter at a given index should be const based on the typedef.
+   *
+   * @param typedefType - The typedef type string
+   * @param paramIndex - The parameter index (0-based)
+   * @returns true if the param should be const, false otherwise, null if unknown
+   */
+  static shouldBeConst(typedefType, paramIndex) {
+    return _TypedefParamParser.getParamAt(typedefType, paramIndex)?.isConst ?? null;
+  }
+};
+var TypedefParamParser_default = TypedefParamParser;
+
 // src/transpiler/output/codegen/helpers/FunctionContextManager.ts
 var FunctionContextManager = class _FunctionContextManager {
   /**
@@ -125510,14 +125688,15 @@ var FunctionContextManager = class _FunctionContextManager {
   static processParameterList(params, callbacks) {
     CodeGenState.currentParameters.clear();
     if (!params) return;
-    for (const param of params.parameter()) {
-      _FunctionContextManager.processParameter(param, callbacks);
+    const paramList = params.parameter();
+    for (let i = 0; i < paramList.length; i++) {
+      _FunctionContextManager.processParameter(paramList[i], callbacks, i);
     }
   }
   /**
    * Process a single parameter declaration.
    */
-  static processParameter(param, callbacks) {
+  static processParameter(param, callbacks, paramIndex) {
     const name = param.IDENTIFIER().getText();
     const isArray = param.arrayDimension().length > 0 || param.type().arrayType() !== null;
     const isConst = param.constModifier() !== null;
@@ -125526,14 +125705,21 @@ var FunctionContextManager = class _FunctionContextManager {
       typeCtx,
       callbacks
     );
+    const callbackTypedefInfo = _FunctionContextManager.getCallbackTypedefParamInfo(paramIndex);
+    const isCallbackPointerParam = callbackTypedefInfo?.shouldBePointer ?? false;
+    const isStruct = callbackTypedefInfo ? isCallbackPointerParam && typeInfo.isStruct : typeInfo.isStruct;
+    const isCallbackPointerPrimitive = isCallbackPointerParam && !typeInfo.isStruct && !isArray;
     const paramInfo = {
       name,
       baseType: typeInfo.typeName,
       isArray,
-      isStruct: typeInfo.isStruct,
+      isStruct,
       isConst,
       isCallback: typeInfo.isCallback,
-      isString: typeInfo.isString
+      isString: typeInfo.isString,
+      isCallbackPointerPrimitive,
+      // Issue #895: Callback-compatible params need pointer semantics even in C++ mode
+      forcePointerSemantics: isCallbackPointerParam
     };
     CodeGenState.currentParameters.set(name, paramInfo);
     _FunctionContextManager.registerParameterType(
@@ -125696,6 +125882,32 @@ var FunctionContextManager = class _FunctionContextManager {
     }
     return dimensions;
   }
+  /**
+   * Issue #895: Get callback typedef parameter info from the C header.
+   * Returns null if not callback-compatible or index is invalid.
+   */
+  static getCallbackTypedefParamInfo(paramIndex) {
+    if (CodeGenState.currentFunctionName === null) return null;
+    const typedefName = CodeGenState.callbackCompatibleFunctions.get(
+      CodeGenState.currentFunctionName
+    );
+    if (!typedefName) return null;
+    const typedefType = CodeGenState.getTypedefType(typedefName);
+    if (!typedefType) return null;
+    const shouldBePointer = TypedefParamParser_default.shouldBePointer(
+      typedefType,
+      paramIndex
+    );
+    const shouldBeConst = TypedefParamParser_default.shouldBeConst(
+      typedefType,
+      paramIndex
+    );
+    if (shouldBePointer === null) return null;
+    return {
+      shouldBePointer,
+      shouldBeConst: shouldBeConst ?? false
+    };
+  }
   /**
    * Extract string capacity from a string type context.
    */
@@ -126488,7 +126700,8 @@ var ParameterInputAdapter = class {
     }
     const isKnownStruct = deps.isKnownStruct(typeName);
     const isKnownPrimitive = !!deps.typeMap[typeName];
-    const isAutoConst = !deps.isModified && !isConst;
+    const isAutoConst = !deps.isCallbackCompatible && !deps.isModified && !isConst;
+    const isPassByReference = deps.forcePassByReference || isKnownStruct || isKnownPrimitive;
     return {
       name,
       baseType: typeName,
@@ -126499,7 +126712,12 @@ var ParameterInputAdapter = class {
       isCallback: false,
       isString: false,
       isPassByValue: deps.isPassByValue,
-      isPassByReference: isKnownStruct || isKnownPrimitive
+      isPassByReference,
+      // Issue #895: Force pointer syntax in C++ mode for callback-compatible functions
+      // because C callback typedefs expect pointers, not C++ references
+      forcePointerSyntax: deps.forcePassByReference,
+      // Issue #895: Preserve const from callback typedef signature
+      forceConst: deps.forceConst
     };
   }
   /**
@@ -126713,11 +126931,15 @@ var ParameterSignatureBuilder = class {
   /**
    * Build pass-by-reference parameter signature.
    * C mode: const Point* p
-   * C++ mode: const Point& p
+   * C++ mode: const Point& p (unless forcePointerSyntax)
+   *
+   * Issue #895: When forcePointerSyntax is set, always use pointer syntax
+   * because C callback typedefs expect pointers, not C++ references.
    */
   static _buildRefParam(param, refSuffix) {
     const constPrefix = this._getConstPrefix(param);
-    return `${constPrefix}${param.mappedType}${refSuffix} ${param.name}`;
+    const actualSuffix = param.forcePointerSyntax ? "*" : refSuffix;
+    return `${constPrefix}${param.mappedType}${actualSuffix} ${param.name}`;
   }
   /**
    * Build unknown type parameter (pass by value, standard C semantics).
@@ -126727,13 +126949,15 @@ var ParameterSignatureBuilder = class {
     return `${constMod}${param.mappedType} ${param.name}`;
   }
   /**
-   * Get const prefix combining explicit const and auto-const.
-   * Auto-const is applied to unmodified parameters.
+   * Get const prefix combining explicit const, auto-const, and forced const.
+   * Priority: forceConst > isConst > isAutoConst
+   * Issue #895: forceConst preserves const from callback typedef signature.
    */
   static _getConstPrefix(param) {
-    const autoConst = param.isAutoConst && !param.isConst ? "const " : "";
-    const explicitConst = param.isConst ? "const " : "";
-    return `${autoConst}${explicitConst}`;
+    if (param.forceConst || param.isConst || param.isAutoConst) {
+      return "const ";
+    }
+    return "";
   }
 };
 var ParameterSignatureBuilder_default = ParameterSignatureBuilder;
@@ -127561,11 +127785,11 @@ var CodeGenerator = class _CodeGenerator {
     TypeValidator_default.validateSwitchStatement(ctx, switchExpr);
   }
   /**
-   * Validate do-while condition.
+   * Validate condition is a boolean expression (ADR-027, Issue #884).
    * Part of IOrchestrator interface (ADR-053 A3).
    */
-  validateDoWhileCondition(ctx) {
-    TypeValidator_default.validateDoWhileCondition(ctx);
+  validateConditionIsBoolean(ctx, conditionType) {
+    TypeValidator_default.validateConditionIsBoolean(ctx, conditionType);
   }
   /**
    * Issue #254: Validate no function calls in condition (E0702).
@@ -127709,7 +127933,7 @@ var CodeGenerator = class _CodeGenerator {
   }
   /** Generate parameter list for function signature */
   generateParameterList(ctx) {
-    return ctx.parameter().map((p) => this.generateParameter(p)).join(", ");
+    return ctx.parameter().map((p, index) => this.generateParameter(p, index)).join(", ");
   }
   /** Get the raw type name without C conversion */
   getTypeName(ctx) {
@@ -127951,8 +128175,8 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
   }
   /**
    * Issue #561: Analyze modifications in a parse tree without full code generation.
-   * Used by Pipeline.transpileSource() to collect modification info from includes
-   * for cross-file const inference (unified with Pipeline.run() behavior).
+   * Used by the transpile() pipeline to collect modification info from includes
+   * for cross-file const inference.
    *
    * Issue #565: Now accepts optional cross-file data for transitive propagation.
    * When a file calls a function from an included file that modifies its param,
@@ -129333,6 +129557,9 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
       return "{}";
     }
     const fieldInits = fields.map((f) => `.${f.fieldName} = ${f.value}`);
+    if (CodeGenState.cppMode && (typeName.startsWith("struct {") || typeName.startsWith("union {"))) {
+      return `{ ${fieldInits.join(", ")} }`;
+    }
     return `(${castType}){ ${fieldInits.join(", ")} }`;
   }
   /**
@@ -129452,13 +129679,17 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
     const typedef = this.generateCallbackTypedef(name);
     return typedef ? functionCode + typedef : functionCode;
   }
-  generateParameter(ctx) {
+  generateParameter(ctx, paramIndex) {
     const typeName = this.getTypeName(ctx.type());
     const name = ctx.IDENTIFIER().getText();
     this._validateCStyleArrayParam(ctx, typeName, name);
     this._validateUnboundedArrayParam(ctx);
     const isModified = this._isCurrentParameterModified(name);
-    const isPassByValue = this._isPassByValueType(typeName, name);
+    const callbackInfo = paramIndex === void 0 ? null : FunctionContextManager_default.getCallbackTypedefParamInfo(paramIndex);
+    const isPassByValue = callbackInfo ? !callbackInfo.shouldBePointer : this._isPassByValueType(typeName, name);
+    const isCallbackCompatible = callbackInfo !== null;
+    const forcePassByReference = callbackInfo?.shouldBePointer ?? false;
+    const forceConst = callbackInfo?.shouldBeConst ?? false;
     const input = ParameterInputAdapter_default.fromAST(ctx, {
       getTypeName: (t) => this.getTypeName(t),
       generateType: (t) => this.generateType(t),
@@ -129467,7 +129698,10 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
       isKnownStruct: (t) => this.isKnownStruct(t),
       typeMap: TYPE_MAP_default,
       isModified,
-      isPassByValue
+      isPassByValue,
+      isCallbackCompatible,
+      forcePassByReference,
+      forceConst
     });
     return ParameterSignatureBuilder_default.build(input, CppModeHelper_default.refOrPtr());
   }
@@ -129516,6 +129750,11 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
     )) {
       return true;
     }
+    if (CodeGenState.currentFunctionName && CodeGenState.callbackCompatibleFunctions.has(
+      CodeGenState.currentFunctionName
+    ) && this.isKnownStruct(typeName)) {
+      return true;
+    }
     return false;
   }
   // ========================================================================
@@ -129800,14 +130039,18 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
     const isStructParam = paramInfo?.isStruct ?? false;
     const isCppAccess = hasGlobal && this.isCppScopeSymbol(firstId);
     const separatorDeps = this._buildMemberSeparatorDeps();
+    const forcePointerSemantics = paramInfo?.forcePointerSemantics ?? false;
     const separatorCtx = MemberSeparatorResolver_default.buildContext(
-      firstId,
-      hasGlobal,
-      hasThis,
-      CodeGenState.currentScope,
-      isStructParam,
-      separatorDeps,
-      isCppAccess
+      {
+        firstId,
+        hasGlobal,
+        hasThis,
+        currentScope: CodeGenState.currentScope,
+        isStructParam,
+        isCppAccess,
+        forcePointerSemantics
+      },
+      separatorDeps
     );
     return {
       generateExpression: (expr) => this.generateExpression(expr),
@@ -130728,8 +130971,11 @@ var HeaderGeneratorUtils = class _HeaderGeneratorUtils {
         lines.push(include);
       }
     }
+    const userIncludeSet = new Set(options.userIncludes ?? []);
     for (const directive of headersToInclude) {
-      lines.push(directive);
+      if (!userIncludeSet.has(directive)) {
+        lines.push(directive);
+      }
     }
     const hasIncludes = options.includeSystemHeaders !== false || options.userIncludes && options.userIncludes.length > 0 || headersToInclude.size > 0;
     if (hasIncludes) {
@@ -133342,8 +133588,9 @@ var CResolver = class _CResolver {
       if (!name) continue;
       const isFunction = DeclaratorUtils_default.declaratorIsFunction(declarator);
       if (ctx.isTypedef) {
+        const typedefType = _CResolver.isFunctionPointerDeclarator(declarator) ? `${baseType} (*)(${_CResolver.extractParamText(declarator)})` : baseType;
         ctx.symbols.push(
-          TypedefCollector_default.collect(name, baseType, ctx.sourceFile, ctx.line)
+          TypedefCollector_default.collect(name, typedefType, ctx.sourceFile, ctx.line)
         );
       } else if (isFunction) {
         ctx.symbols.push(
@@ -133446,6 +133693,36 @@ var CResolver = class _CResolver {
     }
     return typeParts.join(" ") || "int";
   }
+  /**
+   * Check if a declarator represents a function pointer.
+   * For `(*PointCallback)(Point p)`, the C grammar parses as:
+   *   declarator -> directDeclarator
+   *   directDeclarator -> directDeclarator '(' parameterTypeList ')'
+   *   inner directDeclarator -> '(' declarator ')'
+   *   inner declarator -> pointer directDeclarator -> * PointCallback
+   */
+  static isFunctionPointerDeclarator(declarator) {
+    const directDecl = declarator.directDeclarator?.();
+    if (!directDecl) return false;
+    const hasParams = directDecl.parameterTypeList?.() !== null || Boolean(directDecl.LeftParen?.());
+    if (!hasParams) return false;
+    const innerDirectDecl = directDecl.directDeclarator?.();
+    if (!innerDirectDecl) return false;
+    const nestedDecl = innerDirectDecl.declarator?.();
+    if (!nestedDecl) return false;
+    return Boolean(nestedDecl.pointer?.());
+  }
+  /**
+   * Extract parameter text from a function pointer declarator.
+   * Returns the text of the parameters from a function pointer like "(*Callback)(Point p)".
+   */
+  static extractParamText(declarator) {
+    const directDecl = declarator.directDeclarator?.();
+    if (!directDecl) return "";
+    const paramTypeList = directDecl.parameterTypeList?.();
+    if (!paramTypeList) return "";
+    return paramTypeList.getText();
+  }
 };
 var c_default = CResolver;
 
@@ -135075,6 +135352,9 @@ var IncludeResolver = class _IncludeResolver {
     }
     if (file.type === EFileType_default.CNext) {
       result.cnextIncludes.push(file);
+      const headerPath = includeInfo.path.replace(/\.cnx$|\.cnext$/, ".h");
+      const directive = includeInfo.isLocal ? `#include "${headerPath}"` : `#include <${headerPath}>`;
+      result.headerIncludeDirectives.set(absolutePath, directive);
     }
   }
   /**
@@ -135212,8 +135492,8 @@ var IncludeResolver = class _IncludeResolver {
   /**
    * Build search paths from a source file location
    *
-   * Consolidates the search path building logic used by both `run()` and
-   * `transpileSource()` code paths.
+   * Consolidates the search path building logic used by the unified
+   * transpile() entry point.
    *
    * Search order (highest to lowest priority):
    * 1. Source file's directory (for relative includes)
@@ -136548,16 +136828,20 @@ var FunctionCallListener = class extends CNextListener {
   // ========================================================================
   // ISR/Callback Variable Tracking (ADR-040)
   // ========================================================================
+  /**
+   * Check if a type name represents a callable type (ISR, callback, or C function pointer typedef).
+   */
+  isCallableType(typeName) {
+    return typeName === "ISR" || this.analyzer.isCallbackType(typeName) || this.analyzer.isCFunctionPointerTypedef(typeName);
+  }
   /**
    * Track ISR-typed variables from variable declarations
    * e.g., `ISR handler <- myFunction;`
    */
   enterVariableDeclaration = (ctx) => {
-    const typeCtx = ctx.type();
-    const typeName = typeCtx.getText();
-    if (typeName === "ISR" || this.analyzer.isCallbackType(typeName)) {
-      const varName = ctx.IDENTIFIER().getText();
-      this.analyzer.defineCallableVariable(varName);
+    const typeName = ctx.type().getText();
+    if (this.isCallableType(typeName)) {
+      this.analyzer.defineCallableVariable(ctx.IDENTIFIER().getText());
     }
   };
   /**
@@ -136565,11 +136849,9 @@ var FunctionCallListener = class extends CNextListener {
    * e.g., `void execute(ISR handler) { handler(); }`
    */
   enterParameter = (ctx) => {
-    const typeCtx = ctx.type();
-    const typeName = typeCtx.getText();
-    if (typeName === "ISR" || this.analyzer.isCallbackType(typeName)) {
-      const paramName = ctx.IDENTIFIER().getText();
-      this.analyzer.defineCallableVariable(paramName);
+    const typeName = ctx.type().getText();
+    if (this.isCallableType(typeName)) {
+      this.analyzer.defineCallableVariable(ctx.IDENTIFIER().getText());
     }
   };
   // ========================================================================
@@ -136708,6 +136990,7 @@ var FunctionCallAnalyzer = class {
     this.collectIncludes(tree);
     this.collectCallbackTypes(tree);
     this.collectAllLocalFunctions(tree);
+    this.collectCallbackCompatibleFunctions(tree);
     const listener = new FunctionCallListener(this);
     ParseTreeWalker5.DEFAULT.walk(listener, tree);
     return this.errors;
@@ -136791,6 +137074,187 @@ var FunctionCallAnalyzer = class {
   isCallbackType(name) {
     return this.callbackTypes.has(name);
   }
+  /**
+   * Check if a type name is a C function pointer typedef.
+   * Looks up the type in the symbol table and checks if it's a typedef
+   * whose underlying type contains "(*)" indicating a function pointer.
+   */
+  isCFunctionPointerTypedef(typeName) {
+    if (!this.symbolTable) return false;
+    const sym = this.symbolTable.getCSymbol(typeName);
+    if (sym?.kind !== "type") return false;
+    return "type" in sym && typeof sym.type === "string" && sym.type.includes("(*)");
+  }
+  /**
+   * Detect functions assigned to C function pointer typedefs.
+   * When `PointCallback cb <- my_handler;` is found and PointCallback
+   * is a C function pointer typedef, mark my_handler as callback-compatible.
+   */
+  collectCallbackCompatibleFunctions(tree) {
+    for (const decl of tree.declaration()) {
+      const funcDecl = decl.functionDeclaration();
+      if (!funcDecl) continue;
+      const block = funcDecl.block();
+      if (!block) continue;
+      this.scanBlockForCallbackAssignments(block);
+    }
+  }
+  /**
+   * Recursively scan all statements in a block for callback typedef assignments.
+   */
+  scanBlockForCallbackAssignments(block) {
+    for (const stmt of block.statement()) {
+      this.scanStatementForCallbackAssignments(stmt);
+    }
+  }
+  /**
+   * Scan a single statement for callback typedef assignments,
+   * recursing into nested blocks (if/while/for/do-while/switch/critical).
+   */
+  scanStatementForCallbackAssignments(stmt) {
+    const varDecl = stmt.variableDeclaration();
+    if (varDecl) {
+      this.checkVarDeclForCallbackAssignment(varDecl);
+      return;
+    }
+    const exprStmt = stmt.expressionStatement();
+    if (exprStmt) {
+      this.checkExpressionForCallbackArgs(exprStmt.expression());
+      return;
+    }
+    const ifStmt = stmt.ifStatement();
+    if (ifStmt) {
+      for (const child of ifStmt.statement()) {
+        this.scanStatementForCallbackAssignments(child);
+      }
+      return;
+    }
+    const whileStmt = stmt.whileStatement();
+    if (whileStmt) {
+      this.scanStatementForCallbackAssignments(whileStmt.statement());
+      return;
+    }
+    const forStmt = stmt.forStatement();
+    if (forStmt) {
+      this.scanStatementForCallbackAssignments(forStmt.statement());
+      return;
+    }
+    const doWhileStmt = stmt.doWhileStatement();
+    if (doWhileStmt) {
+      this.scanBlockForCallbackAssignments(doWhileStmt.block());
+      return;
+    }
+    const switchStmt = stmt.switchStatement();
+    if (switchStmt) {
+      for (const caseCtx of switchStmt.switchCase()) {
+        this.scanBlockForCallbackAssignments(caseCtx.block());
+      }
+      const defaultCtx = switchStmt.defaultCase();
+      if (defaultCtx) {
+        this.scanBlockForCallbackAssignments(defaultCtx.block());
+      }
+      return;
+    }
+    const criticalStmt = stmt.criticalStatement();
+    if (criticalStmt) {
+      this.scanBlockForCallbackAssignments(criticalStmt.block());
+      return;
+    }
+    const nestedBlock = stmt.block();
+    if (nestedBlock) {
+      this.scanBlockForCallbackAssignments(nestedBlock);
+    }
+  }
+  /**
+   * Check if a variable declaration assigns a function to a C callback typedef.
+   */
+  checkVarDeclForCallbackAssignment(varDecl) {
+    const typeName = varDecl.type().getText();
+    if (!this.isCFunctionPointerTypedef(typeName)) return;
+    const expr = varDecl.expression();
+    if (!expr) return;
+    const funcRef = this.extractFunctionReference(expr);
+    if (!funcRef) return;
+    const lookupName = funcRef.includes(".") ? funcRef.replace(".", "_") : funcRef;
+    if (this.allLocalFunctions.has(lookupName)) {
+      CodeGenState.callbackCompatibleFunctions.set(lookupName, typeName);
+    }
+  }
+  /**
+   * Extract a function reference from an expression context.
+   * Matches bare identifiers (e.g., "my_handler") and qualified scope
+   * names (e.g., "MyScope.handler").
+   * Returns null if the expression is not a function reference.
+   */
+  extractFunctionReference(expr) {
+    const text = expr.getText();
+    if (/^\w+(\.\w+)?$/.test(text)) {
+      return text;
+    }
+    return null;
+  }
+  /**
+   * Issue #895: Check expression for function calls that pass C-Next functions
+   * to C function pointer parameters.
+   *
+   * Pattern: `global.widget_set_flush_cb(w, my_flush)`
+   * Where widget_set_flush_cb's 2nd param is a C function pointer typedef.
+   */
+  checkExpressionForCallbackArgs(expr) {
+    const postfix = this.findPostfixExpression(expr);
+    if (!postfix) return;
+    const callInfo = this.extractCallInfo(postfix);
+    if (!callInfo) return;
+    const cFunc = this.symbolTable?.getCSymbol(callInfo.funcName);
+    if (cFunc?.kind !== "function" || !cFunc.parameters) return;
+    for (let i = 0; i < callInfo.args.length; i++) {
+      const param = cFunc.parameters[i];
+      if (!param) continue;
+      if (!this.isCFunctionPointerTypedef(param.type)) continue;
+      const funcRef = this.extractFunctionReference(callInfo.args[i]);
+      if (!funcRef) continue;
+      const lookupName = funcRef.includes(".") ? funcRef.replace(".", "_") : funcRef;
+      if (this.allLocalFunctions.has(lookupName)) {
+        CodeGenState.callbackCompatibleFunctions.set(lookupName, param.type);
+      }
+    }
+  }
+  /**
+   * Find the postfix expression within an expression tree.
+   * Uses ExpressionUnwrapper which validates that expression is "simple"
+   * (single term at each level), returning null for complex expressions.
+   */
+  findPostfixExpression(expr) {
+    return ExpressionUnwrapper_default.getPostfixExpression(expr);
+  }
+  /**
+   * Extract function name and arguments from a postfix expression.
+   * Returns null if not a function call.
+   */
+  extractCallInfo(postfix) {
+    const primary = postfix.primaryExpression();
+    const ops = postfix.postfixOp();
+    const ident = primary.IDENTIFIER();
+    const globalKw = primary.GLOBAL();
+    if (!ident && !globalKw) {
+      return null;
+    }
+    let funcName = ident ? ident.getText() : "";
+    let argListOp = null;
+    for (const op of ops) {
+      if (op.IDENTIFIER()) {
+        const member = op.IDENTIFIER().getText();
+        funcName = funcName ? `${funcName}_${member}` : member;
+      } else if (op.argumentList() || op.getText().startsWith("(")) {
+        argListOp = op;
+        break;
+      }
+    }
+    if (!argListOp || !funcName) return null;
+    const argList = argListOp.argumentList();
+    const args = argList?.expression() ?? [];
+    return { funcName, args };
+  }
   /**
    * ADR-040: Register a variable that holds a callable (ISR or callback)
    */
@@ -137044,6 +137508,26 @@ var TypeConstants = class {
     "float",
     "double"
   ];
+  /**
+   * Unsigned integer types valid as array/bit subscript indexes.
+   *
+   * Used by:
+   * - ArrayIndexTypeAnalyzer: validating subscript index types
+   */
+  static UNSIGNED_INDEX_TYPES = [
+    "u8",
+    "u16",
+    "u32",
+    "u64",
+    "bool"
+  ];
+  /**
+   * Signed integer types (rejected as subscript indexes).
+   *
+   * Used by:
+   * - ArrayIndexTypeAnalyzer: detecting signed integer subscript indexes
+   */
+  static SIGNED_TYPES = ["i8", "i16", "i32", "i64"];
 };
 var TypeConstants_default = TypeConstants;
 
@@ -137161,6 +137645,212 @@ var FloatModuloAnalyzer = class {
 };
 var FloatModuloAnalyzer_default = FloatModuloAnalyzer;
 
+// src/transpiler/logic/analysis/ArrayIndexTypeAnalyzer.ts
+import { ParseTreeWalker as ParseTreeWalker8 } from "antlr4ng";
+var VariableTypeCollector = class extends CNextListener {
+  varTypes = /* @__PURE__ */ new Map();
+  getVarTypes() {
+    return this.varTypes;
+  }
+  trackType(typeCtx, identifier) {
+    if (!typeCtx || !identifier) return;
+    this.varTypes.set(identifier.getText(), typeCtx.getText());
+  }
+  enterVariableDeclaration = (ctx) => {
+    this.trackType(ctx.type(), ctx.IDENTIFIER());
+  };
+  enterParameter = (ctx) => {
+    this.trackType(ctx.type(), ctx.IDENTIFIER());
+  };
+  enterForVarDecl = (ctx) => {
+    this.trackType(ctx.type(), ctx.IDENTIFIER());
+  };
+};
+var IndexTypeListener = class extends CNextListener {
+  analyzer;
+  // eslint-disable-next-line @typescript-eslint/lines-between-class-members
+  varTypes;
+  constructor(analyzer, varTypes) {
+    super();
+    this.analyzer = analyzer;
+    this.varTypes = varTypes;
+  }
+  /**
+   * Check postfix operations in expressions (RHS: arr[idx], flags[bit])
+   */
+  enterPostfixOp = (ctx) => {
+    if (!ctx.LBRACKET()) return;
+    const expressions = ctx.expression();
+    for (const expr of expressions) {
+      this.validateIndexExpression(expr);
+    }
+  };
+  /**
+   * Check postfix target operations in assignments (LHS: arr[idx] <- val)
+   */
+  enterPostfixTargetOp = (ctx) => {
+    if (!ctx.LBRACKET()) return;
+    const expressions = ctx.expression();
+    for (const expr of expressions) {
+      this.validateIndexExpression(expr);
+    }
+  };
+  /**
+   * Validate that a subscript index expression uses an unsigned integer type.
+   * Collects all leaf operands from the expression and checks each one.
+   */
+  validateIndexExpression(ctx) {
+    const operands = this.collectOperands(ctx);
+    for (const operand of operands) {
+      const resolvedType = this.resolveOperandType(operand);
+      if (!resolvedType) continue;
+      if (TypeConstants_default.SIGNED_TYPES.includes(resolvedType)) {
+        const { line: line2, column: column2 } = ParserUtils_default.getPosition(ctx);
+        this.analyzer.addError(line2, column2, "E0850", resolvedType);
+        return;
+      }
+      if (resolvedType === "float literal" || TypeConstants_default.FLOAT_TYPES.includes(resolvedType)) {
+        const { line: line2, column: column2 } = ParserUtils_default.getPosition(ctx);
+        this.analyzer.addError(line2, column2, "E0851", resolvedType);
+        return;
+      }
+      if (TypeConstants_default.UNSIGNED_INDEX_TYPES.includes(resolvedType)) {
+        continue;
+      }
+      const { line, column } = ParserUtils_default.getPosition(ctx);
+      this.analyzer.addError(line, column, "E0852", resolvedType);
+      return;
+    }
+  }
+  /**
+   * Collect all leaf unary expression operands from an expression tree.
+   * Handles binary operators at any level by flatMapping through the grammar hierarchy.
+   */
+  collectOperands(ctx) {
+    const ternary = ctx.ternaryExpression();
+    if (!ternary) return [];
+    const orExpressions = ternary.orExpression();
+    if (orExpressions.length === 0) return [];
+    const valueExpressions = orExpressions.length === 3 ? orExpressions.slice(1) : orExpressions;
+    return valueExpressions.flatMap((o) => o.andExpression()).flatMap((a) => a.equalityExpression()).flatMap((e) => e.relationalExpression()).flatMap((r) => r.bitwiseOrExpression()).flatMap((bo) => bo.bitwiseXorExpression()).flatMap((bx) => bx.bitwiseAndExpression()).flatMap((ba) => ba.shiftExpression()).flatMap((s) => s.additiveExpression()).flatMap((a) => a.multiplicativeExpression()).flatMap((m) => m.unaryExpression());
+  }
+  /**
+   * Resolve the type of a unary expression operand.
+   * Uses local varTypes first, then falls back to CodeGenState for
+   * struct fields, function return types, and enum detection.
+   *
+   * Returns null if the type cannot be resolved (pass-through).
+   */
+  resolveOperandType(operand) {
+    const postfixExpr = operand.postfixExpression();
+    if (!postfixExpr) return null;
+    const primaryExpr = postfixExpr.primaryExpression();
+    if (!primaryExpr) return null;
+    let currentType = this.resolveBaseType(primaryExpr);
+    const postfixOps = postfixExpr.postfixOp();
+    if (!currentType && postfixOps.length > 0) {
+      const identifier = primaryExpr.IDENTIFIER();
+      if (identifier) {
+        currentType = identifier.getText();
+      }
+    }
+    for (const op of postfixOps) {
+      if (!currentType) return null;
+      currentType = this.resolvePostfixOpType(currentType, op);
+    }
+    return currentType;
+  }
+  /**
+   * Resolve the base type of a primary expression.
+   */
+  resolveBaseType(primaryExpr) {
+    const literal = primaryExpr.literal();
+    if (literal) {
+      if (LiteralUtils_default.isFloat(literal)) return "float literal";
+      return null;
+    }
+    const parenExpr = primaryExpr.expression();
+    if (parenExpr) {
+      const innerOperands = this.collectOperands(parenExpr);
+      for (const innerOp of innerOperands) {
+        const innerType = this.resolveOperandType(innerOp);
+        if (innerType) return innerType;
+      }
+      return null;
+    }
+    const identifier = primaryExpr.IDENTIFIER();
+    if (!identifier) return null;
+    const varName = identifier.getText();
+    const localType = this.varTypes.get(varName);
+    if (localType) return localType;
+    const typeInfo = CodeGenState.getVariableTypeInfo(varName);
+    if (typeInfo) return typeInfo.baseType;
+    return null;
+  }
+  /**
+   * Resolve the resulting type after applying a postfix operator.
+   */
+  resolvePostfixOpType(currentType, op) {
+    if (op.DOT()) {
+      const fieldId = op.IDENTIFIER();
+      if (!fieldId) return null;
+      const fieldName = fieldId.getText();
+      if (CodeGenState.isKnownEnum(currentType)) return null;
+      const fieldType = CodeGenState.getStructFieldType(currentType, fieldName);
+      return fieldType ?? null;
+    }
+    if (op.LBRACKET()) {
+      if (TypeConstants_default.UNSIGNED_INDEX_TYPES.includes(currentType)) {
+        return "bool";
+      }
+      if (TypeConstants_default.SIGNED_TYPES.includes(currentType)) {
+        return "bool";
+      }
+      return currentType;
+    }
+    if (op.LPAREN()) {
+      const returnType = CodeGenState.getFunctionReturnType(currentType);
+      return returnType ?? null;
+    }
+    return null;
+  }
+};
+var ArrayIndexTypeAnalyzer = class {
+  errors = [];
+  /**
+   * Analyze the parse tree for invalid subscript index types
+   */
+  analyze(tree) {
+    this.errors = [];
+    const collector = new VariableTypeCollector();
+    ParseTreeWalker8.DEFAULT.walk(collector, tree);
+    const varTypes = collector.getVarTypes();
+    const listener = new IndexTypeListener(this, varTypes);
+    ParseTreeWalker8.DEFAULT.walk(listener, tree);
+    return this.errors;
+  }
+  /**
+   * Add an index type error
+   */
+  addError(line, column, code, actualType) {
+    this.errors.push({
+      code,
+      line,
+      column,
+      actualType,
+      message: `Subscript index must be an unsigned integer type; got '${actualType}'`,
+      helpText: "Use an unsigned integer type (u8, u16, u32, u64) for array and bit subscript indexes."
+    });
+  }
+  /**
+   * Get all detected errors
+   */
+  getErrors() {
+    return this.errors;
+  }
+};
+var ArrayIndexTypeAnalyzer_default = ArrayIndexTypeAnalyzer;
+
 // src/transpiler/logic/analysis/runAnalyzers.ts
 function collectErrors(analyzerErrors, target, formatMessage) {
   const formatter = formatMessage ?? ((e) => e.message);
@@ -137214,6 +137904,10 @@ function runAnalyzers(tree, tokenStream, options) {
   if (collectErrors(floatModAnalyzer.analyze(tree), errors, formatWithCode)) {
     return errors;
   }
+  const indexTypeAnalyzer = new ArrayIndexTypeAnalyzer_default();
+  if (collectErrors(indexTypeAnalyzer.analyze(tree), errors, formatWithCode)) {
+    return errors;
+  }
   const commentExtractor = new CommentExtractor_default(tokenStream);
   collectErrors(
     commentExtractor.validate(),
@@ -137821,7 +138515,7 @@ var TransitiveEnumCollector = class {
   /**
    * Collect symbol info for standalone mode from resolved includes.
    *
-   * Issue #591: Extracted from Transpiler.transpileSource() to unify enum collection.
+   * Issue #591: Extracted to unify enum collection across transpilation modes.
    * Unlike collect() which starts from a file path and parses it, this method
    * starts from already-resolved includes (from IncludeResolver.resolve()).
    *
@@ -137899,83 +138593,53 @@ var Transpiler = class {
     this.cacheManager = projectRoot ? new CacheManager_default(projectRoot, this.fs) : null;
   }
   // ===========================================================================
-  // Public API: run() and transpileSource()
+  // Public API
   // ===========================================================================
   /**
-   * Execute the unified pipeline from CLI inputs.
+   * Unified entry point for all transpilation.
    *
-   * Stage 1 (file discovery) happens here, then delegates to _executePipeline().
+   * @param input - What to transpile:
+   *   - { kind: 'files' } — discover from config.inputs, write to disk
+   *   - { kind: 'source', source, ... } — transpile in-memory source
+   * @returns ITranspilerResult with per-file results in .files[]
    */
-  async run() {
+  async transpile(input) {
     const result = this._initResult();
     try {
       await this._initializeRun();
-      const { cnextFiles, headerFiles } = await this.discoverSources();
-      if (cnextFiles.length === 0) {
+      const pipelineInput = await this.discoverIncludes(input);
+      if (pipelineInput.cnextFiles.length === 0) {
         return this._finalizeResult(result, "No C-Next source files found");
       }
-      this._ensureOutputDirectories();
-      const pipelineFiles = cnextFiles.map((f) => ({
-        path: f.path,
-        discoveredFile: f
-      }));
-      const input = {
-        cnextFiles: pipelineFiles,
-        headerFiles,
-        writeOutputToDisk: true
-      };
-      await this._executePipeline(input, result);
+      if (input.kind === "files") {
+        this._ensureOutputDirectories();
+      }
+      await this._executePipeline(pipelineInput, result);
       return await this._finalizeResult(result);
     } catch (err) {
       return this._handleRunError(result, err);
     }
   }
   /**
-   * Transpile source code provided as a string.
+   * Stage 1: Discover files and build pipeline input.
    *
-   * Discovers includes from the source, builds an IPipelineInput, and
-   * delegates to the same _executePipeline() as run().
+   * Branches on input kind:
+   * - 'files': filesystem scan, dependency graph, topological sort
+   * - 'source': parse in-memory string, walk include tree
    *
-   * @param source - The C-Next source code as a string
-   * @param options - Options for transpilation
-   * @returns Promise<IFileResult> with generated code or errors
-   */
-  async transpileSource(source, options) {
-    const workingDir = options?.workingDir ?? process.cwd();
-    const additionalIncludeDirs = options?.includeDirs ?? [];
-    const sourcePath = options?.sourcePath ?? "<string>";
-    try {
-      await this._initializeRun();
-      const input = this._discoverFromSource(
-        source,
-        workingDir,
-        additionalIncludeDirs,
-        sourcePath
-      );
-      const result = this._initResult();
-      await this._executePipeline(input, result);
-      const fileResult = result.files.find((f) => f.sourcePath === sourcePath);
-      if (fileResult) {
-        return fileResult;
-      }
-      if (result.errors.length > 0) {
-        return this.buildErrorResult(sourcePath, result.errors, 0);
-      }
-      return this.buildErrorResult(
-        sourcePath,
-        [
-          {
-            line: 1,
-            column: 0,
-            message: "Pipeline produced no result for source file",
-            severity: "error"
-          }
-        ],
-        0
-      );
-    } catch (err) {
-      return this.buildCatchResult(sourcePath, err);
-    }
+   * Header directive storage happens via IncludeResolver.resolve() for both
+   * C headers and cnext includes (Issue #854).
+   */
+  async discoverIncludes(input) {
+    if (input.kind === "files") {
+      return this._discoverFromFiles();
+    }
+    return this._discoverFromSource(
+      input.source,
+      input.workingDir ?? process.cwd(),
+      input.includeDirs ?? [],
+      input.sourcePath ?? "<string>"
+    );
   }
   // ===========================================================================
   // Unified Pipeline
@@ -137983,7 +138647,7 @@ var Transpiler = class {
   /**
    * The single unified pipeline for all transpilation.
    *
-   * Both run() and transpileSource() delegate here after file discovery.
+   * transpile() delegates here after file discovery via discoverIncludes().
    *
    * Stage 2: Collect symbols from C/C++ headers (includes building analyzer context)
    * Stage 3: Collect symbols from C-Next files
@@ -138090,14 +138754,6 @@ var Transpiler = class {
       if (this.config.parseOnly) {
         return this.buildParseOnlyResult(sourcePath, declarationCount);
       }
-      const analyzerErrors = runAnalyzers_default(tree, tokenStream);
-      if (analyzerErrors.length > 0) {
-        return this.buildErrorResult(
-          sourcePath,
-          analyzerErrors,
-          declarationCount
-        );
-      }
       const tSymbols = cnext_default.resolve(tree, sourcePath);
       let symbolInfo = TSymbolInfoAdapter_default.convert(tSymbols);
       const externalEnumSources = this._collectExternalEnumSources(
@@ -138110,6 +138766,15 @@ var Transpiler = class {
           externalEnumSources
         );
       }
+      CodeGenState.symbols = symbolInfo;
+      const analyzerErrors = runAnalyzers_default(tree, tokenStream);
+      if (analyzerErrors.length > 0) {
+        return this.buildErrorResult(
+          sourcePath,
+          analyzerErrors,
+          declarationCount
+        );
+      }
       this._setupCrossFileModifications();
       const code = this.codeGenerator.generate(tree, tokenStream, {
         debugMode: this.config.debugMode,
@@ -138127,15 +138792,7 @@ var Transpiler = class {
       if (this.cppDetected) {
         this._accumulateFileModifications();
       }
-      const fileSymbols = CodeGenState.symbolTable.getTSymbolsByFile(sourcePath);
-      const headerCode = this.generateHeaderContent(
-        fileSymbols,
-        sourcePath,
-        this.cppDetected,
-        userIncludes,
-        passByValueCopy,
-        symbolInfo
-      );
+      const headerCode = this.generateHeaderForFile(file) ?? void 0;
       return this.buildSuccessResult(
         sourcePath,
         code,
@@ -138200,6 +138857,13 @@ var Transpiler = class {
         this.state.setHeaderDirective(header.path, directive);
       }
     }
+    for (const cnxInclude of resolved.cnextIncludes) {
+      const includePath = resolve12(cnxInclude.path);
+      const directive = resolved.headerIncludeDirectives.get(includePath);
+      if (directive) {
+        this.state.setHeaderDirective(includePath, directive);
+      }
+    }
     const cnextIncludeFiles = [];
     IncludeTreeWalker_default.walk(
       resolved.cnextIncludes,
@@ -138257,6 +138921,7 @@ var Transpiler = class {
     this.state.reset();
     CodeGenState.symbolTable.clear();
     SymbolRegistry_default.reset();
+    CodeGenState.callbackCompatibleFunctions = /* @__PURE__ */ new Map();
   }
   /**
    * Ensure output directories exist
@@ -138335,8 +139000,12 @@ var Transpiler = class {
       if (file.symbolOnly) {
         continue;
       }
-      const headerPath = this.generateHeader(file.discoveredFile);
-      if (headerPath) {
+      const headerContent = this.generateHeaderForFile(file);
+      if (headerContent) {
+        const headerPath = this.pathResolver.getHeaderOutputPath(
+          file.discoveredFile
+        );
+        this.fs.writeFile(headerPath, headerContent);
         result.outputFiles.push(headerPath);
       }
     }
@@ -138370,7 +139039,7 @@ var Transpiler = class {
     return result;
   }
   // ===========================================================================
-  // Source Discovery (Stage 1 for run())
+  // File Discovery (Stage 1 for files mode)
   // ===========================================================================
   /**
    * Discover C-Next files from a single input (file or directory).
@@ -138431,6 +139100,10 @@ var Transpiler = class {
         ""
       );
       depGraph.addDependency(cnxPath, includePath);
+      const directive = resolved.headerIncludeDirectives.get(includePath);
+      if (directive) {
+        this.state.setHeaderDirective(includePath, directive);
+      }
       const alreadyExists = cnextBaseNames.has(includeBaseName) || cnextFiles.some((f) => resolve12(f.path) === includePath);
       if (!alreadyExists) {
         cnextFiles.push(cnxInclude);
@@ -138494,14 +139167,14 @@ var Transpiler = class {
    * This ensures headers are found based on what the source actually
    * includes, not by blindly scanning include directories.
    */
-  async discoverSources() {
+  async _discoverFromFiles() {
     const cnextFiles = [];
     const fileByPath = /* @__PURE__ */ new Map();
     for (const input of this.config.inputs) {
       this._discoverCNextFromInput(input, cnextFiles, fileByPath);
     }
     if (cnextFiles.length === 0) {
-      return { cnextFiles: [], headerFiles: [] };
+      return { cnextFiles: [], headerFiles: [], writeOutputToDisk: true };
     }
     const headerSet = /* @__PURE__ */ new Map();
     const depGraph = new DependencyGraph_default();
@@ -138529,9 +139202,14 @@ var Transpiler = class {
       }
     );
     this.warnings.push(...headerWarnings);
+    const pipelineFiles = sortedCnextFiles.map((f) => ({
+      path: f.path,
+      discoveredFile: f
+    }));
     return {
-      cnextFiles: sortedCnextFiles,
-      headerFiles: allHeaders
+      cnextFiles: pipelineFiles,
+      headerFiles: allHeaders,
+      writeOutputToDisk: true
     };
   }
   // ===========================================================================
@@ -138716,17 +139394,22 @@ var Transpiler = class {
    * Stage 6: Generate header file for a C-Next file
    * ADR-055 Phase 7: Uses TSymbol directly, converts to IHeaderSymbol for generation.
    */
-  generateHeader(file) {
-    const tSymbols = CodeGenState.symbolTable.getTSymbolsByFile(file.path);
+  /**
+   * Generate header content for a single file's exported symbols.
+   * Unified method replacing both generateHeader() and generateHeaderContent().
+   * Reads all needed data from state (populated during Stage 5).
+   */
+  generateHeaderForFile(file) {
+    const sourcePath = file.path;
+    const tSymbols = CodeGenState.symbolTable.getTSymbolsByFile(sourcePath);
     const exportedSymbols = tSymbols.filter((s) => s.isExported);
     if (exportedSymbols.length === 0) {
       return null;
     }
-    const headerName = basename5(file.path).replace(/\.cnx$|\.cnext$/, ".h");
-    const headerPath = this.pathResolver.getHeaderOutputPath(file);
-    const typeInput = this.state.getSymbolInfo(file.path);
-    const passByValueParams = this.state.getPassByValueParams(file.path) ?? /* @__PURE__ */ new Map();
-    const userIncludes = this.state.getUserIncludes(file.path);
+    const headerName = basename5(sourcePath).replace(/\.cnx$|\.cnext$/, ".h");
+    const typeInput = this.state.getSymbolInfo(sourcePath);
+    const passByValueParams = this.state.getPassByValueParams(sourcePath) ?? /* @__PURE__ */ new Map();
+    const userIncludes = this.state.getUserIncludes(sourcePath);
     const allKnownEnums = TransitiveEnumCollector_default.aggregateKnownEnums(
       this.state.getAllSymbolInfo()
     );
@@ -138741,7 +139424,7 @@ var Transpiler = class {
       unmodifiedParams,
       allKnownEnums
     );
-    const headerContent = this.headerGenerator.generate(
+    return this.headerGenerator.generate(
       headerSymbols,
       headerName,
       {
@@ -138754,8 +139437,6 @@ var Transpiler = class {
       passByValueParams,
       allKnownEnums
     );
-    this.fs.writeFile(headerPath, headerContent);
-    return headerPath;
   }
   /**
    * Collect external enum sources from included C-Next files.
@@ -138788,43 +139469,6 @@ var Transpiler = class {
       );
     }
   }
-  /**
-   * Generate header content for exported symbols.
-   * Issue #591: Extracted from transpileSource() for reduced complexity.
-   * ADR-055 Phase 7: Works with TSymbol[], converts to IHeaderSymbol for generation.
-   */
-  generateHeaderContent(tSymbols, sourcePath, cppMode, userIncludes, passByValueParams, symbolInfo) {
-    const exportedSymbols = tSymbols.filter((s) => s.isExported);
-    if (exportedSymbols.length === 0) {
-      return void 0;
-    }
-    const unmodifiedParams = this.codeGenerator.getFunctionUnmodifiedParams();
-    const headerSymbols = this.convertToHeaderSymbols(
-      exportedSymbols,
-      unmodifiedParams,
-      symbolInfo.knownEnums
-    );
-    const headerName = basename5(sourcePath).replace(/\.cnx$|\.cnext$/, ".h");
-    const typeInput = CodeGenState.symbols;
-    const externalTypeHeaders = ExternalTypeHeaderBuilder_default.build(
-      this.state.getAllHeaderDirectives(),
-      CodeGenState.symbolTable
-    );
-    const typeInputWithSymbolTable = typeInput ? { ...typeInput, symbolTable: CodeGenState.symbolTable } : void 0;
-    return this.headerGenerator.generate(
-      headerSymbols,
-      headerName,
-      {
-        exportedOnly: true,
-        userIncludes,
-        externalTypeHeaders,
-        cppMode
-      },
-      typeInputWithSymbolTable,
-      passByValueParams,
-      symbolInfo.knownEnums
-    );
-  }
   /**
    * Convert TSymbols to IHeaderSymbols with auto-const information applied.
    * ADR-055 Phase 7: Replaces mutation-based auto-const updating.
@@ -139032,7 +139676,7 @@ var Runner = class {
       target: config.target,
       debugMode: config.debugMode
     });
-    const result = await pipeline.run();
+    const result = await pipeline.transpile({ kind: "files" });
     this._renameOutputIfNeeded(result, explicitOutputFile);
     ResultPrinter_default.print(result);
     process.exit(result.success ? 0 : 1);
@@ -139742,16 +140386,31 @@ var ServeCommand = class _ServeCommand {
     }
     const { source, filePath } = params;
     const options = filePath ? { workingDir: dirname11(filePath), sourcePath: filePath } : void 0;
-    const result = await _ServeCommand.transpiler.transpileSource(
+    const transpileResult = await _ServeCommand.transpiler.transpile({
+      kind: "source",
       source,
-      options
-    );
+      ...options
+    });
+    const fileResult = transpileResult.files.find(
+      (f) => f.sourcePath === (filePath ?? "<string>")
+    ) ?? transpileResult.files[0];
+    if (!fileResult) {
+      return {
+        success: true,
+        result: {
+          success: false,
+          code: "",
+          errors: transpileResult.errors,
+          cppDetected: _ServeCommand.transpiler.isCppDetected()
+        }
+      };
+    }
     return {
       success: true,
       result: {
-        success: result.success,
-        code: result.code,
-        errors: result.errors,
+        success: fileResult.success,
+        code: fileResult.code,
+        errors: fileResult.errors,
         cppDetected: _ServeCommand.transpiler.isCppDetected()
       }
     };
@@ -139765,7 +140424,9 @@ var ServeCommand = class _ServeCommand {
     const { source, filePath } = params;
     if (_ServeCommand.transpiler && filePath) {
       try {
-        await _ServeCommand.transpiler.transpileSource(source, {
+        await _ServeCommand.transpiler.transpile({
+          kind: "source",
+          source,
           workingDir: dirname11(filePath),
           sourcePath: filePath
         });