c-next 0.2.15 → 0.2.17

package/dist/index.js

@@ -11,7 +11,7 @@ import { hideBin } from "yargs/helpers";
 // package.json
 var package_default = {
   name: "c-next",
-  version: "0.2.15",
+  version: "0.2.17",
   description: "A safer C for embedded systems development. Transpiles to clean, readable C.",
   packageManager: "npm@11.9.0",
   type: "module",
@@ -35,6 +35,10 @@ var package_default = {
     "test:update": "tsx scripts/test.ts --update",
     "integration:transpile": "tsx scripts/test.ts --transpile-only",
     "integration:execute": "tsx scripts/test.ts --execute-only",
+    "test:bugs": "tsx scripts/test.ts -- bugs",
+    "test:bugs:q": "tsx scripts/test.ts -- bugs -q",
+    "integration:bugs:transpile": "tsx scripts/test.ts -- bugs --transpile-only",
+    "integration:bugs:execute": "tsx scripts/test.ts -- bugs --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 .",
@@ -16039,21 +16043,10 @@ var CNextParser = class _CNextParser extends antlr2.Parser {
     this.enterRule(localContext, 170, _CNextParser.RULE_arrayType);
     let _la;
     try {
-      this.state = 921;
+      this.state = 939;
       this.errorHandler.sync(this);
-      switch (this.tokenStream.LA(1)) {
-        case _CNextParser.U8:
-        case _CNextParser.U16:
-        case _CNextParser.U32:
-        case _CNextParser.U64:
-        case _CNextParser.I8:
-        case _CNextParser.I16:
-        case _CNextParser.I32:
-        case _CNextParser.I64:
-        case _CNextParser.F32:
-        case _CNextParser.F64:
-        case _CNextParser.BOOL:
-        case _CNextParser.ISR_TYPE:
+      switch (this.interpreter.adaptivePredict(this.tokenStream, 98, this.context)) {
+        case 1:
           this.enterOuterAlt(localContext, 1);
           {
             this.state = 903;
@@ -16074,7 +16067,7 @@ var CNextParser = class _CNextParser extends antlr2.Parser {
             } while (_la === 100);
           }
           break;
-        case _CNextParser.IDENTIFIER:
+        case 2:
           this.enterOuterAlt(localContext, 2);
           {
             this.state = 909;
@@ -16095,7 +16088,7 @@ var CNextParser = class _CNextParser extends antlr2.Parser {
             } while (_la === 100);
           }
           break;
-        case _CNextParser.STRING:
+        case 3:
           this.enterOuterAlt(localContext, 3);
           {
             this.state = 915;
@@ -16116,8 +16109,69 @@ var CNextParser = class _CNextParser extends antlr2.Parser {
             } while (_la === 100);
           }
           break;
-        default:
-          throw new antlr2.NoViableAltException(this);
+        case 4:
+          this.enterOuterAlt(localContext, 4);
+          {
+            this.state = 921;
+            this.scopedType();
+            this.state = 923;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+              {
+                {
+                  this.state = 922;
+                  this.arrayTypeDimension();
+                }
+              }
+              this.state = 925;
+              this.errorHandler.sync(this);
+              _la = this.tokenStream.LA(1);
+            } while (_la === 100);
+          }
+          break;
+        case 5:
+          this.enterOuterAlt(localContext, 5);
+          {
+            this.state = 927;
+            this.qualifiedType();
+            this.state = 929;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+              {
+                {
+                  this.state = 928;
+                  this.arrayTypeDimension();
+                }
+              }
+              this.state = 931;
+              this.errorHandler.sync(this);
+              _la = this.tokenStream.LA(1);
+            } while (_la === 100);
+          }
+          break;
+        case 6:
+          this.enterOuterAlt(localContext, 6);
+          {
+            this.state = 933;
+            this.globalType();
+            this.state = 935;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+              {
+                {
+                  this.state = 934;
+                  this.arrayTypeDimension();
+                }
+              }
+              this.state = 937;
+              this.errorHandler.sync(this);
+              _la = this.tokenStream.LA(1);
+            } while (_la === 100);
+          }
+          break;
       }
     } catch (re) {
       if (re instanceof antlr2.RecognitionException) {
@@ -16138,18 +16192,18 @@ var CNextParser = class _CNextParser extends antlr2.Parser {
     try {
       this.enterOuterAlt(localContext, 1);
       {
-        this.state = 923;
+        this.state = 941;
         this.match(_CNextParser.LBRACKET);
-        this.state = 925;
+        this.state = 943;
         this.errorHandler.sync(this);
         _la = this.tokenStream.LA(1);
         if ((_la & ~31) === 0 && (1 << _la & 2147532800) !== 0 || (_la - 32 & ~31) === 0 && (1 << _la - 32 & 1966091) !== 0 || (_la - 83 & ~31) === 0 && (1 << _la - 83 & 2130879681) !== 0) {
           {
-            this.state = 924;
+            this.state = 942;
             this.expression();
           }
         }
-        this.state = 927;
+        this.state = 945;
         this.match(_CNextParser.RBRACKET);
       }
     } catch (re) {
@@ -16171,7 +16225,7 @@ var CNextParser = class _CNextParser extends antlr2.Parser {
     try {
       this.enterOuterAlt(localContext, 1);
       {
-        this.state = 929;
+        this.state = 947;
         _la = this.tokenStream.LA(1);
         if (!((_la - 31 & ~31) === 0 && (1 << _la - 31 & 3932167) !== 0 || (_la - 107 & ~31) === 0 && (1 << _la - 107 & 63) !== 0)) {
           this.errorHandler.recoverInline(this);
@@ -16196,7 +16250,7 @@ var CNextParser = class _CNextParser extends antlr2.Parser {
     4,
     1,
     117,
-    932,
+    950,
     2,
     0,
     7,
@@ -18171,9 +18225,51 @@ var CNextParser = class _CNextParser extends antlr2.Parser {
     12,
     85,
     919,
+    1,
+    85,
+    1,
+    85,
+    4,
+    85,
+    924,
+    8,
+    85,
+    11,
+    85,
+    12,
+    85,
+    925,
+    1,
+    85,
+    1,
+    85,
+    4,
+    85,
+    930,
+    8,
+    85,
+    11,
+    85,
+    12,
+    85,
+    931,
+    1,
+    85,
+    1,
+    85,
+    4,
+    85,
+    936,
+    8,
+    85,
+    11,
+    85,
+    12,
+    85,
+    937,
     3,
     85,
-    922,
+    940,
     8,
     85,
     1,
@@ -18182,7 +18278,7 @@ var CNextParser = class _CNextParser extends antlr2.Parser {
     86,
     3,
     86,
-    926,
+    944,
     8,
     86,
     1,
@@ -18348,7 +18444,7 @@ var CNextParser = class _CNextParser extends antlr2.Parser {
     52,
     107,
     112,
-    988,
+    1012,
     0,
     180,
     1,
@@ -18860,19 +18956,19 @@ var CNextParser = class _CNextParser extends antlr2.Parser {
     0,
     0,
     170,
-    921,
+    939,
     1,
     0,
     0,
     0,
     172,
-    923,
+    941,
     1,
     0,
     0,
     0,
     174,
-    929,
+    947,
     1,
     0,
     0,
@@ -24110,7 +24206,7 @@ var CNextParser = class _CNextParser extends antlr2.Parser {
     0,
     0,
     908,
-    922,
+    940,
     1,
     0,
     0,
@@ -24152,7 +24248,7 @@ var CNextParser = class _CNextParser extends antlr2.Parser {
     0,
     0,
     914,
-    922,
+    940,
     1,
     0,
     0,
@@ -24194,90 +24290,234 @@ var CNextParser = class _CNextParser extends antlr2.Parser {
     0,
     0,
     920,
-    922,
+    940,
     1,
     0,
     0,
     0,
     921,
+    923,
+    3,
+    152,
+    76,
+    0,
+    922,
+    924,
+    3,
+    172,
+    86,
+    0,
+    923,
+    922,
+    1,
+    0,
+    0,
+    0,
+    924,
+    925,
+    1,
+    0,
+    0,
+    0,
+    925,
+    923,
+    1,
+    0,
+    0,
+    0,
+    925,
+    926,
+    1,
+    0,
+    0,
+    0,
+    926,
+    940,
+    1,
+    0,
+    0,
+    0,
+    927,
+    929,
+    3,
+    156,
+    78,
+    0,
+    928,
+    930,
+    3,
+    172,
+    86,
+    0,
+    929,
+    928,
+    1,
+    0,
+    0,
+    0,
+    930,
+    931,
+    1,
+    0,
+    0,
+    0,
+    931,
+    929,
+    1,
+    0,
+    0,
+    0,
+    931,
+    932,
+    1,
+    0,
+    0,
+    0,
+    932,
+    940,
+    1,
+    0,
+    0,
+    0,
+    933,
+    935,
+    3,
+    154,
+    77,
+    0,
+    934,
+    936,
+    3,
+    172,
+    86,
+    0,
+    935,
+    934,
+    1,
+    0,
+    0,
+    0,
+    936,
+    937,
+    1,
+    0,
+    0,
+    0,
+    937,
+    935,
+    1,
+    0,
+    0,
+    0,
+    937,
+    938,
+    1,
+    0,
+    0,
+    0,
+    938,
+    940,
+    1,
+    0,
+    0,
+    0,
+    939,
     903,
     1,
     0,
     0,
     0,
-    921,
+    939,
     909,
     1,
     0,
     0,
     0,
-    921,
+    939,
     915,
     1,
     0,
     0,
     0,
-    922,
+    939,
+    921,
+    1,
+    0,
+    0,
+    0,
+    939,
+    927,
+    1,
+    0,
+    0,
+    0,
+    939,
+    933,
+    1,
+    0,
+    0,
+    0,
+    940,
     171,
     1,
     0,
     0,
     0,
-    923,
-    925,
+    941,
+    943,
     5,
     100,
     0,
     0,
-    924,
-    926,
+    942,
+    944,
     3,
     102,
     51,
     0,
-    925,
-    924,
+    943,
+    942,
     1,
     0,
     0,
     0,
-    925,
-    926,
+    943,
+    944,
     1,
     0,
     0,
     0,
-    926,
-    927,
+    944,
+    945,
     1,
     0,
     0,
     0,
-    927,
-    928,
+    945,
+    946,
     5,
     101,
     0,
     0,
-    928,
+    946,
     173,
     1,
     0,
     0,
     0,
-    929,
-    930,
+    947,
+    948,
     7,
     13,
     0,
     0,
-    930,
+    948,
     175,
     1,
     0,
     0,
     0,
-    97,
+    100,
     178,
     180,
     186,
@@ -24373,8 +24613,11 @@ var CNextParser = class _CNextParser extends antlr2.Parser {
     907,
     913,
     919,
-    921,
-    925
+    925,
+    931,
+    937,
+    939,
+    943
   ];
   static __ATN;
   static get _ATN() {
@@ -27875,6 +28118,15 @@ var ArrayTypeContext = class extends antlr2.ParserRuleContext {
   stringType() {
     return this.getRuleContext(0, StringTypeContext);
   }
+  scopedType() {
+    return this.getRuleContext(0, ScopedTypeContext);
+  }
+  qualifiedType() {
+    return this.getRuleContext(0, QualifiedTypeContext);
+  }
+  globalType() {
+    return this.getRuleContext(0, GlobalTypeContext);
+  }
   get ruleIndex() {
     return CNextParser.RULE_arrayType;
   }
@@ -111383,7 +111635,7 @@ var ESourceLanguage = /* @__PURE__ */ ((ESourceLanguage2) => {
 var ESourceLanguage_default = ESourceLanguage;
 
 // src/utils/LiteralUtils.ts
-var LiteralUtils = class {
+var LiteralUtils = class _LiteralUtils {
   /**
    * Check if a literal represents zero.
    *
@@ -111418,8 +111670,25 @@ var LiteralUtils = class {
     if (ctx.SUFFIXED_BINARY()) {
       return text.startsWith("0b0u") || text.startsWith("0b0i") || text.startsWith("0B0u") || text.startsWith("0B0i");
     }
+    if (ctx.FLOAT_LITERAL()) {
+      return _LiteralUtils.isFloatZero(text);
+    }
     return false;
   }
+  /**
+   * Check if a float literal string represents zero.
+   * Issue #1010: Detect float zero for division-by-zero checking.
+   *
+   * Handles: 0.0, .0, 0., 0.0f, 0.0F, 0.0e0, 0.0E0, etc.
+   *
+   * @param text - The float literal text
+   * @returns true if the float is zero
+   */
+  static isFloatZero(text) {
+    const withoutSuffix = text.replace(/[fF]$/, "");
+    const value = Number.parseFloat(withoutSuffix);
+    return value === 0;
+  }
   /**
    * Check if a literal is a floating-point number.
    *
@@ -111792,19 +112061,17 @@ var SymbolTable = class {
   /**
    * Register struct fields in structFields map for cross-file type resolution.
    * Called automatically when adding struct symbols.
+   * Issue #981: Now preserves string dimensions (macro names) for proper array detection.
    */
   registerStructFields(struct) {
     const cName = SymbolNameUtils_default.getTranspiledCName(struct);
     for (const [fieldName, fieldInfo] of struct.fields) {
       const typeString = TypeResolver_default.getTypeName(fieldInfo.type);
-      const numericDims = fieldInfo.dimensions?.filter(
-        (d) => typeof d === "number"
-      );
       this.addStructField(
         cName,
         fieldName,
         typeString,
-        numericDims && numericDims.length > 0 ? numericDims : void 0
+        fieldInfo.dimensions && fieldInfo.dimensions.length > 0 ? fieldInfo.dimensions : void 0
       );
     }
   }
@@ -111917,6 +112184,7 @@ var SymbolTable = class {
   // ========================================================================
   /**
    * Add a C symbol to the table
+   * Issue #981: Also register struct fields for type resolution
    */
   addCSymbol(symbol) {
     const existing = this.cSymbols.get(symbol.name);
@@ -111931,6 +112199,23 @@ var SymbolTable = class {
     } else {
       this.cSymbolsByFile.set(symbol.sourceFile, [symbol]);
     }
+    if (symbol.kind === "struct" && symbol.fields) {
+      this.registerCStructFields(symbol.name, symbol.fields);
+    }
+  }
+  /**
+   * Register C struct fields in structFields map for cross-file type resolution.
+   * Issue #981: Required for macro-sized array field detection on local struct variables.
+   */
+  registerCStructFields(structName, fields) {
+    for (const [fieldName, fieldInfo] of fields) {
+      this.addStructField(
+        structName,
+        fieldName,
+        fieldInfo.type,
+        fieldInfo.arrayDimensions
+      );
+    }
   }
   /**
    * Add multiple C symbols at once
@@ -112265,11 +112550,12 @@ Rename the C-Next symbol to resolve.`
   // Struct Field Information
   // ========================================================================
   /**
-   * Add struct field information
+   * Add struct field information.
+   * Issue #981: Accept (number | string)[] for arrayDimensions to support macro-sized arrays.
    * @param structName Name of the struct
    * @param fieldName Name of the field
    * @param fieldType Type of the field (e.g., "uint32_t")
-   * @param arrayDimensions Optional array dimensions if field is an array
+   * @param arrayDimensions Optional array dimensions - numbers for resolved, strings for macros
    */
   addStructField(structName, fieldName, fieldType, arrayDimensions) {
     let fields = this.structFields.get(structName);
@@ -112279,7 +112565,7 @@ Rename the C-Next symbol to resolve.`
     }
     fields.set(fieldName, {
       type: fieldType,
-      arrayDimensions
+      arrayDimensions: arrayDimensions ? [...arrayDimensions] : void 0
     });
   }
   /**
@@ -112522,12 +112808,23 @@ Rename the C-Next symbol to resolve.`
    * Issue #958: Check if a typedef aliases a struct type.
    * Used for scope variables, function parameters, and local variables
    * which should be pointers for C-header struct types.
+   *
+   * Issue #948: Performs query-time resolution - if the underlying struct
+   * tag has a full body definition, this is NOT an external typedef struct
+   * (it's a complete type that can use value semantics).
+   *
    * @param typeName The type name to check
    * @returns true if this is a typedef'd struct type from C headers
    */
   isTypedefStructType(typeName) {
-    const result = this.structState.typedefStructTypes.has(typeName);
-    return result;
+    if (!this.structState.typedefStructTypes.has(typeName)) {
+      return false;
+    }
+    const tag = this.structState.typedefToTag.get(typeName);
+    if (tag && this.structState.structTagsWithBodies.has(tag)) {
+      return false;
+    }
+    return true;
   }
   /**
    * Issue #958: Get all typedef struct types for cache serialization.
@@ -112781,6 +113078,11 @@ var CodeGenState = class _CodeGenState {
   static indentLevel = 0;
   /** Whether we're inside a function body */
   static inFunctionBody = false;
+  /** Whether we're generating the RHS of a variable declaration initializer.
+   *  When true, struct literals use { .field = value } instead of (Type){ .field = value }
+   *  because plain designated initializers are valid C99 at any scope, while compound
+   *  literals are not constant expressions and fail at file scope on GCC < 13. */
+  static inDeclarationInit = false;
   /** Expected type for struct initializers and enum inference */
   static expectedType = null;
   /**
@@ -112893,6 +113195,7 @@ var CodeGenState = class _CodeGenState {
     this.floatShadowCurrent = /* @__PURE__ */ new Set();
     this.indentLevel = 0;
     this.inFunctionBody = false;
+    this.inDeclarationInit = false;
     this.expectedType = null;
     this.suppressBareEnumResolution = false;
     this.mainArgsName = null;
@@ -112972,6 +113275,46 @@ var CodeGenState = class _CodeGenState {
       this.suppressBareEnumResolution = savedSuppress;
     }
   }
+  /** Execute fn with inDeclarationInit=true, restoring prior value on exit. */
+  static withDeclarationInit(fn) {
+    const saved = this.inDeclarationInit;
+    this.inDeclarationInit = true;
+    try {
+      return fn();
+    } finally {
+      this.inDeclarationInit = saved;
+    }
+  }
+  /** Execute fn with inDeclarationInit=false, restoring prior value on exit.
+   *  Used in sub-expression contexts (function args, ternary arms) where
+   *  plain designated initializers are not valid C. */
+  static withoutDeclarationInit(fn) {
+    const saved = this.inDeclarationInit;
+    this.inDeclarationInit = false;
+    try {
+      return fn();
+    } finally {
+      this.inDeclarationInit = saved;
+    }
+  }
+  /**
+   * Execute fn with expectedType=null, restoring prior value on exit.
+   * Issue #1032: Used in comparison contexts (relational/equality expressions)
+   * where MISRA 7.2 U suffix should NOT be applied - comparing `i32 < 0`
+   * should not generate `signedIdx < 0U` which changes comparison semantics.
+   */
+  static withoutExpectedType(fn) {
+    const savedType = this.expectedType;
+    const savedSuppress = this.suppressBareEnumResolution;
+    this.expectedType = null;
+    this.suppressBareEnumResolution = false;
+    try {
+      return fn();
+    } finally {
+      this.expectedType = savedType;
+      this.suppressBareEnumResolution = savedSuppress;
+    }
+  }
   // ===========================================================================
   // CONVENIENCE LOOKUP METHODS
   // ===========================================================================
@@ -113508,14 +113851,27 @@ var CodeGenState = class _CodeGenState {
     this.opaqueScopeVariables.add(qualifiedName);
   }
   /**
-   * Check if a scope variable has an opaque type (and is thus a pointer).
-   * Used during access generation to determine if & prefix is needed.
+   * Check if generated code accesses an opaque scope variable (and is thus
+   * already a pointer). Used during argument generation to decide whether an
+   * address-of (&) prefix is needed.
    *
-   * @param qualifiedName - The fully qualified variable name (e.g., "MyScope_widget")
-   * @returns true if this is an opaque scope variable (already a pointer)
+   * Handles two forms:
+   * - Direct access:        "MyScope_widget"     → the handle itself (pointer)
+   * - Array-element access: "MyScope_widgets[i]" → an element of an opaque
+   *   handle array, which is itself a pointer (Issue #996)
+   *
+   * @param generatedCode - The generated access expression (e.g. "UI_widgets[i]")
+   * @returns true if this resolves to an opaque scope variable (already a pointer)
    */
-  static isOpaqueScopeVariable(qualifiedName) {
-    return this.opaqueScopeVariables.has(qualifiedName);
+  static isOpaqueScopeVariableAccess(generatedCode) {
+    if (this.opaqueScopeVariables.has(generatedCode)) {
+      return true;
+    }
+    const bracketIndex = generatedCode.indexOf("[");
+    if (bracketIndex === -1) {
+      return false;
+    }
+    return this.opaqueScopeVariables.has(generatedCode.slice(0, bracketIndex));
   }
   // ===========================================================================
   // C++ MODE HELPERS
@@ -113675,6 +114031,22 @@ var ScopeUtils = class _ScopeUtils {
     return scope.name === "" && scope.parent === scope;
   }
   // ============================================================================
+  // Visibility Utilities
+  // ============================================================================
+  /**
+   * ADR-016: Get the default visibility for a scope member based on its type.
+   *
+   * Member-type-aware defaults reduce boilerplate:
+   * - Functions: public by default (API surface)
+   * - Variables/types: private by default (internal state)
+   *
+   * @param isFunction - Whether the member is a function declaration
+   * @returns The default visibility for this member type
+   */
+  static getDefaultVisibility(isFunction) {
+    return isFunction ? "public" : "private";
+  }
+  // ============================================================================
   // Path Utilities
   // ============================================================================
   /**
@@ -114409,41 +114781,73 @@ var TypeRegistrationEngine = class _TypeRegistrationEngine {
     });
     return true;
   }
+  /**
+   * Issue #1029: Register type info for string arrays (string<N>[M]).
+   *
+   * String arrays are parsed as arrayType with stringType inside:
+   *   arrayType -> stringType arrayTypeDimension+
+   *
+   * For `string<32>[4] items`:
+   *   - stringType gives capacity 32
+   *   - arrayTypeDimension gives [4]
+   *   - Result: char items[4][33] with dimensions [4, 33]
+   */
+  static _registerStringArrayType(registryName, arrayTypeCtx, arrayDim, isConst, overflowBehavior, isAtomic, callbacks) {
+    const stringCtx = arrayTypeCtx.stringType();
+    const intLiteral = stringCtx.INTEGER_LITERAL();
+    if (!intLiteral) {
+      return;
+    }
+    const capacity = Number.parseInt(intLiteral.getText(), 10);
+    callbacks.requireInclude("string");
+    const stringDim = capacity + 1;
+    const arrayTypeDims = arrayTypeCtx.arrayTypeDimension().map((dim) => dim.expression()).filter((expr) => expr !== null).map((expr) => Number.parseInt(expr.getText(), 10)).filter((size) => !Number.isNaN(size));
+    const additionalDims = ArrayDimensionParser_default.parseSimpleDimensions(arrayDim);
+    const dimensions = [...arrayTypeDims, ...additionalDims, stringDim];
+    CodeGenState.setVariableTypeInfo(registryName, {
+      baseType: "char",
+      bitWidth: 8,
+      isArray: true,
+      arrayDimensions: dimensions,
+      isConst,
+      isString: true,
+      stringCapacity: capacity,
+      overflowBehavior,
+      isAtomic
+    });
+  }
   // ============================================================================
   // Array and standard type registration
   // ============================================================================
   static _registerArrayTypeVariable(registryName, arrayTypeCtx, arrayDim, isConst, overflowBehavior, isAtomic, callbacks) {
-    let baseType = "";
-    let bitWidth = 0;
-    if (arrayTypeCtx.primitiveType()) {
-      baseType = arrayTypeCtx.primitiveType().getText();
-      bitWidth = TYPE_WIDTH_default[baseType] || 0;
-    } else if (arrayTypeCtx.userType()) {
-      baseType = arrayTypeCtx.userType().getText();
-      const combinedArrayDim = arrayDim ?? [];
-      if (_TypeRegistrationEngine._tryRegisterEnumOrBitmapType(
+    if (arrayTypeCtx.stringType()) {
+      _TypeRegistrationEngine._registerStringArrayType(
         registryName,
-        baseType,
+        arrayTypeCtx,
+        arrayDim,
         isConst,
-        combinedArrayDim,
         overflowBehavior,
         isAtomic,
         callbacks
-      )) {
-        const existingInfo = CodeGenState.getVariableTypeInfo(registryName);
-        if (existingInfo) {
-          const arrayTypeDim = _TypeRegistrationEngine.parseArrayTypeDimension(arrayTypeCtx);
-          const allDims = arrayTypeDim ? [arrayTypeDim, ...existingInfo.arrayDimensions ?? []] : existingInfo.arrayDimensions;
-          CodeGenState.setVariableTypeInfo(registryName, {
-            ...existingInfo,
-            isArray: true,
-            arrayDimensions: allDims
-          });
-        }
+      );
+      return;
+    }
+    if (arrayTypeCtx.userType()) {
+      const registered = _TypeRegistrationEngine._tryRegisterUserTypeArray(
+        registryName,
+        arrayTypeCtx,
+        arrayDim,
+        isConst,
+        overflowBehavior,
+        isAtomic,
+        callbacks
+      );
+      if (registered) {
         return;
       }
     }
-    if (!baseType) {
+    const typeInfo = _TypeRegistrationEngine._extractArrayBaseTypeInfo(arrayTypeCtx);
+    if (!typeInfo.baseType) {
       return;
     }
     const arrayDimensions = _TypeRegistrationEngine._collectArrayDimensions(
@@ -114452,8 +114856,8 @@ var TypeRegistrationEngine = class _TypeRegistrationEngine {
       callbacks
     );
     CodeGenState.setVariableTypeInfo(registryName, {
-      baseType,
-      bitWidth,
+      baseType: typeInfo.baseType,
+      bitWidth: typeInfo.bitWidth,
       isArray: true,
       arrayDimensions: arrayDimensions.length > 0 ? arrayDimensions : void 0,
       isConst,
@@ -114461,6 +114865,64 @@ var TypeRegistrationEngine = class _TypeRegistrationEngine {
       isAtomic
     });
   }
+  /**
+   * Extract base type and bit width from an array type context.
+   * Handles primitive, qualified, scoped, and user types.
+   */
+  static _extractArrayBaseTypeInfo(arrayTypeCtx) {
+    if (arrayTypeCtx.primitiveType()) {
+      const baseType = arrayTypeCtx.primitiveType().getText();
+      return { baseType, bitWidth: TYPE_WIDTH_default[baseType] || 0 };
+    }
+    if (arrayTypeCtx.qualifiedType()) {
+      const parts = arrayTypeCtx.qualifiedType().IDENTIFIER();
+      return { baseType: parts.map((p) => p.getText()).join("_"), bitWidth: 0 };
+    }
+    if (arrayTypeCtx.scopedType()) {
+      const typeName = arrayTypeCtx.scopedType().IDENTIFIER().getText();
+      const baseType = CodeGenState.currentScope ? `${CodeGenState.currentScope}_${typeName}` : typeName;
+      return { baseType, bitWidth: 0 };
+    }
+    if (arrayTypeCtx.globalType()) {
+      const typeName = arrayTypeCtx.globalType().IDENTIFIER().getText();
+      return { baseType: typeName, bitWidth: 0 };
+    }
+    if (arrayTypeCtx.userType()) {
+      return { baseType: arrayTypeCtx.userType().getText(), bitWidth: 0 };
+    }
+    return { baseType: "", bitWidth: 0 };
+  }
+  /**
+   * Try to register a user type array as enum or bitmap.
+   * Returns true if registration was handled, false if it should fall through.
+   */
+  static _tryRegisterUserTypeArray(registryName, arrayTypeCtx, arrayDim, isConst, overflowBehavior, isAtomic, callbacks) {
+    const baseType = arrayTypeCtx.userType().getText();
+    const combinedArrayDim = arrayDim ?? [];
+    const registered = _TypeRegistrationEngine._tryRegisterEnumOrBitmapType(
+      registryName,
+      baseType,
+      isConst,
+      combinedArrayDim,
+      overflowBehavior,
+      isAtomic,
+      callbacks
+    );
+    if (!registered) {
+      return false;
+    }
+    const existingInfo = CodeGenState.getVariableTypeInfo(registryName);
+    if (existingInfo) {
+      const arrayTypeDim = _TypeRegistrationEngine.parseArrayTypeDimension(arrayTypeCtx);
+      const allDims = arrayTypeDim ? [arrayTypeDim, ...existingInfo.arrayDimensions ?? []] : existingInfo.arrayDimensions;
+      CodeGenState.setVariableTypeInfo(registryName, {
+        ...existingInfo,
+        isArray: true,
+        arrayDimensions: allDims
+      });
+    }
+    return true;
+  }
   static _collectArrayDimensions(arrayTypeCtx, arrayDim, callbacks) {
     const arrayDimensions = [];
     for (const dim of arrayTypeCtx.arrayTypeDimension()) {
@@ -116956,18 +117418,10 @@ var generateEqualityExpr = (node, input, state, orchestrator) => {
     const rightIsString = orchestrator.isStringExpression(exprs[1]);
     if (leftIsString || rightIsString) {
       effects.push({ type: "include", header: "string" });
-      const leftResult = generateRelationalExpr(
-        exprs[0],
-        input,
-        state,
-        orchestrator
-      );
-      const rightResult = generateRelationalExpr(
-        exprs[1],
-        input,
-        state,
-        orchestrator
-      );
+      const [leftResult, rightResult] = CodeGenState.withoutExpectedType(() => [
+        generateRelationalExpr(exprs[0], input, state, orchestrator),
+        generateRelationalExpr(exprs[1], input, state, orchestrator)
+      ]);
       effects.push(...leftResult.effects, ...rightResult.effects);
       const fullText = node.getText();
       const isNotEqual = fullText.includes("!=");
@@ -116982,13 +117436,15 @@ var generateEqualityExpr = (node, input, state, orchestrator) => {
     }
   }
   const operators = orchestrator.getOperatorsFromChildren(node);
-  return accumulateBinaryExprs(
-    exprs,
-    operators,
-    "=",
-    generateRelationalExpr,
-    { input, state, orchestrator },
-    BinaryExprUtils_default.mapEqualityOperator
+  return CodeGenState.withoutExpectedType(
+    () => accumulateBinaryExprs(
+      exprs,
+      operators,
+      "=",
+      generateRelationalExpr,
+      { input, state, orchestrator },
+      BinaryExprUtils_default.mapEqualityOperator
+    )
   );
 };
 var generateRelationalExpr = (node, input, state, orchestrator) => {
@@ -116997,11 +117453,13 @@ var generateRelationalExpr = (node, input, state, orchestrator) => {
     return generateBitwiseOrExpr(exprs[0], input, state, orchestrator);
   }
   const operators = orchestrator.getOperatorsFromChildren(node);
-  return accumulateBinaryExprs(exprs, operators, "<", generateBitwiseOrExpr, {
-    input,
-    state,
-    orchestrator
-  });
+  return CodeGenState.withoutExpectedType(
+    () => accumulateBinaryExprs(exprs, operators, "<", generateBitwiseOrExpr, {
+      input,
+      state,
+      orchestrator
+    })
+  );
 };
 var generateBitwiseOrExpr = (node, input, state, orchestrator) => {
   const effects = [];
@@ -117191,8 +117649,12 @@ var generateTernaryExpr = (node, _input, _state, orchestrator) => {
   orchestrator.validateNoNestedTernary(falseExpr, "false branch");
   orchestrator.validateTernaryConditionNoFunctionCall(condition);
   const condCode = orchestrator.generateOrExpr(condition);
-  const trueCode = orchestrator.generateOrExpr(trueExpr);
-  const falseCode = orchestrator.generateOrExpr(falseExpr);
+  const trueCode = CodeGenState.withoutDeclarationInit(
+    () => orchestrator.generateOrExpr(trueExpr)
+  );
+  const falseCode = CodeGenState.withoutDeclarationInit(
+    () => orchestrator.generateOrExpr(falseExpr)
+  );
   return { code: `(${condCode}) ? ${trueCode} : ${falseCode}`, effects };
 };
 var expressionGenerators = {
@@ -117403,7 +117865,7 @@ var _generateCFunctionArg = (e, targetParam, input, orchestrator) => {
   if (typeInfo?.isPointer) {
     isPointerVariable = true;
   }
-  const isOpaqueScopeVar = CodeGenState.isOpaqueScopeVariable(argCode);
+  const isOpaqueScopeVar = CodeGenState.isOpaqueScopeVariableAccess(argCode);
   const needsAddressOf = argType && !argType.endsWith("*") && !argCode.startsWith("&") && !targetParam.isArray && !isPointerVariable && !isOpaqueScopeVar && (orchestrator.isStructType(argType) || _parameterExpectsAddressOf(targetParam.baseType, argType, orchestrator));
   const finalArgCode = needsAddressOf ? `&${argCode}` : argCode;
   return wrapWithCppEnumCast(
@@ -117440,39 +117902,41 @@ var generateFunctionCall = (funcExpr, argCtx, input, _state, orchestrator) => {
     trackPassThroughModifications(funcExpr, argExprs, orchestrator);
   }
   const sig = input.functionSignatures.get(funcExpr);
-  const args = argExprs.map((e, idx) => {
-    const resolved = CallExprUtils_default.resolveTargetParam(
-      sig,
-      idx,
-      funcExpr,
-      input.symbolTable
-    );
-    const targetParam = resolved.param;
-    if (!isCNextFunc) {
-      return _generateCFunctionArg(e, targetParam, input, orchestrator);
-    }
-    if (_shouldPassByValue(
-      funcExpr,
-      idx,
-      targetParam,
-      resolved.isCrossFile,
-      orchestrator
-    )) {
-      const argCode = CodeGenState.withExpectedType(
-        targetParam?.baseType,
-        () => orchestrator.generateExpression(e),
-        true
-        // suppressEnumResolution
+  const args = CodeGenState.withoutDeclarationInit(
+    () => argExprs.map((e, idx) => {
+      const resolved = CallExprUtils_default.resolveTargetParam(
+        sig,
+        idx,
+        funcExpr,
+        input.symbolTable
       );
-      return wrapWithCppEnumCast(
-        argCode,
-        e,
-        targetParam?.baseType,
+      const targetParam = resolved.param;
+      if (!isCNextFunc) {
+        return _generateCFunctionArg(e, targetParam, input, orchestrator);
+      }
+      if (_shouldPassByValue(
+        funcExpr,
+        idx,
+        targetParam,
+        resolved.isCrossFile,
         orchestrator
-      );
-    }
-    return orchestrator.generateFunctionArg(e, targetParam?.baseType);
-  }).join(", ");
+      )) {
+        const argCode = CodeGenState.withExpectedType(
+          targetParam?.baseType,
+          () => orchestrator.generateExpression(e),
+          true
+          // suppressEnumResolution
+        );
+        return wrapWithCppEnumCast(
+          argCode,
+          e,
+          targetParam?.baseType,
+          orchestrator
+        );
+      }
+      return orchestrator.generateFunctionArg(e, targetParam?.baseType);
+    }).join(", ")
+  );
   return { code: `${funcExpr}(${args})`, effects };
 };
 var generateSafeDivMod = (funcName, argExprs, input, orchestrator, effects) => {
@@ -119915,7 +120379,9 @@ function generateInitializer(varDecl, isArray, orchestrator) {
     const typeName = orchestrator.generateType(varDecl.type());
     return CodeGenState.withExpectedType(
       typeName,
-      () => ` = ${orchestrator.generateExpression(varDecl.expression())}`
+      () => CodeGenState.withDeclarationInit(
+        () => ` = ${orchestrator.generateExpression(varDecl.expression())}`
+      )
     );
   }
   return ` = ${orchestrator.getZeroInitializer(varDecl.type(), isArray)}`;
@@ -119993,9 +120459,19 @@ function generateRegularVariable(varDecl, varName, scopeName, isPrivate, orchest
     type = `${type}*`;
     orchestrator.markOpaqueScopeVariable(fullName);
   }
+  const modifiers = VariableModifierBuilder_default.build(
+    varDecl,
+    false,
+    // inFunctionBody - scope vars are file scope
+    false,
+    // hasInitializer - doesn't affect volatile/atomic handling
+    false
+    // cppMode - doesn't affect volatile/atomic handling
+  );
+  const staticPrefix = isPrivate ? "static " : "";
+  const volatilePrefix = modifiers.atomic || modifiers.volatile;
   const constPrefix = isConst ? "const " : "";
-  const prefix = isPrivate ? "static " : "";
-  let decl = `${prefix}${constPrefix}${type} ${fullName}`;
+  let decl = `${staticPrefix}${volatilePrefix}${constPrefix}${type} ${fullName}`;
   decl += ArrayDimensionUtils_default.generateArrayTypeDimension(
     arrayTypeCtx,
     orchestrator
@@ -120004,7 +120480,7 @@ function generateRegularVariable(varDecl, varName, scopeName, isPrivate, orchest
     decl += orchestrator.generateArrayDimensions(arrayDims);
   }
   decl += ArrayDimensionUtils_default.generateStringCapacityDim(varDecl.type());
-  if (isOpaque || isExternalStruct) {
+  if ((isOpaque || isExternalStruct) && !isArray) {
     decl += " = NULL";
   } else {
     decl += generateInitializer(varDecl, isArray, orchestrator);
@@ -120061,7 +120537,9 @@ function generateEnumMembersFromAST(members, fullName, orchestrator) {
   return lines;
 }
 function processScopeMember(member, scopeName, input, state, orchestrator) {
-  const visibility = member.visibilityModifier()?.getText() || "private";
+  const explicitVisibility = member.visibilityModifier()?.getText();
+  const isFunction = member.functionDeclaration() !== null;
+  const visibility = explicitVisibility ?? ScopeUtils_default.getDefaultVisibility(isFunction);
   const isPrivate = visibility === "private";
   if (member.variableDeclaration()) {
     const varDecl = member.variableDeclaration();
@@ -125837,19 +126315,6 @@ var SymbolLookupHelper = class _SymbolLookupHelper {
     const symbols = symbolTable.getOverloads(name);
     return symbols.some((sym) => sym.kind === "namespace");
   }
-  /**
-   * Check if a type name is from a C++ header.
-   * Issue #304: Used to determine whether to use {} or {0} for initialization.
-   * C++ types with constructors may fail with {0} but work with {}.
-   */
-  static isCppType(symbolTable, typeName) {
-    if (!symbolTable) return false;
-    const symbols = symbolTable.getOverloads(typeName);
-    const cppTypeKinds = /* @__PURE__ */ new Set(["struct", "class", "type"]);
-    return symbols.some(
-      (sym) => sym.sourceLanguage === ESourceLanguage_default.Cpp && cppTypeKinds.has(sym.kind)
-    );
-  }
   /**
    * Check if a function is a C-Next function (uses pass-by-reference semantics).
    * Returns true if the function is found in symbol table as C-Next.
@@ -126189,6 +126654,18 @@ var StringDeclHelper = class _StringDeclHelper {
    * Returns { handled: false } if not a string type.
    */
   static generateStringDecl(typeCtx, name, expression, arrayDims, modifiers, isConst, callbacks) {
+    const arrayTypeCtx = typeCtx.arrayType?.();
+    if (arrayTypeCtx?.stringType?.()) {
+      return _StringDeclHelper._generateStringArrayFromArrayType(
+        name,
+        arrayTypeCtx,
+        expression,
+        arrayDims,
+        modifiers,
+        isConst,
+        callbacks
+      );
+    }
     const stringCtx = typeCtx.stringType();
     if (!stringCtx) {
       return { code: "", handled: false };
@@ -126215,6 +126692,122 @@ var StringDeclHelper = class _StringDeclHelper {
       );
     }
   }
+  /**
+   * Issue #1029: Generate string array declaration from arrayType syntax.
+   * Handles: string<32>[4] items -> char items[4][33] = {0};
+   */
+  static _generateStringArrayFromArrayType(name, arrayTypeCtx, expression, trailingArrayDims, modifiers, isConst, callbacks) {
+    const stringCtx = arrayTypeCtx.stringType();
+    const intLiteral = stringCtx.INTEGER_LITERAL();
+    if (!intLiteral) {
+      throw new Error(
+        "Error: String arrays require explicit capacity, e.g., string<64>[4]"
+      );
+    }
+    const capacity = Number.parseInt(intLiteral.getText(), 10);
+    callbacks.requireStringInclude();
+    const {
+      extern,
+      const: constMod,
+      atomic,
+      volatile: volatileMod
+    } = modifiers;
+    let arrayDimStr = "";
+    for (const dim of arrayTypeCtx.arrayTypeDimension()) {
+      const sizeExpr = dim.expression();
+      if (sizeExpr) {
+        arrayDimStr += `[${sizeExpr.getText()}]`;
+      } else {
+        arrayDimStr += "[]";
+      }
+    }
+    arrayDimStr += callbacks.generateArrayDimensions(trailingArrayDims);
+    arrayDimStr += `[${capacity + 1}]`;
+    let decl = `${extern}${constMod}${atomic}${volatileMod}char ${name}${arrayDimStr}`;
+    CodeGenState.localArrays.add(name);
+    if (!expression) {
+      return { code: `${decl} = {0};`, handled: true };
+    }
+    CodeGenState.lastArrayInitCount = 0;
+    CodeGenState.lastArrayFillValue = void 0;
+    const initValue = callbacks.generateExpression(expression);
+    const isArrayInit = CodeGenState.lastArrayInitCount > 0 || CodeGenState.lastArrayFillValue !== void 0;
+    if (!isArrayInit) {
+      throw new Error(
+        `Error: String array initialization from variables not supported`
+      );
+    }
+    const declaredSize = _StringDeclHelper._getArrayTypeDeclaredSize(arrayTypeCtx);
+    if (declaredSize !== null) {
+      const isFillAll = CodeGenState.lastArrayFillValue !== void 0;
+      const elementCount = CodeGenState.lastArrayInitCount;
+      if (!isFillAll && elementCount !== declaredSize) {
+        throw new Error(
+          `Error: Array size mismatch - declared [${declaredSize}] but got ${elementCount} elements`
+        );
+      }
+    }
+    const finalInitValue = _StringDeclHelper._expandFillAllForArrayType(
+      initValue,
+      arrayTypeCtx
+    );
+    const suppression = "// cppcheck-suppress misra-c2012-9.3\n// cppcheck-suppress misra-c2012-9.4\n";
+    return {
+      code: `${suppression}${decl} = ${finalInitValue};`,
+      handled: true
+    };
+  }
+  /**
+   * Get the numeric size from the first arrayTypeDimension, or null if not numeric.
+   * Used by arrayType-based string arrays (string<N>[M]).
+   */
+  static _getArrayTypeDeclaredSize(arrayTypeCtx) {
+    const dims = arrayTypeCtx.arrayTypeDimension();
+    if (dims.length === 0) {
+      return null;
+    }
+    const firstDimExpr = dims[0].expression();
+    return _StringDeclHelper._parseNumericSize(firstDimExpr);
+  }
+  /**
+   * Expand fill-all syntax for arrayType-based string arrays.
+   * Delegates to the common fill-all expansion logic with size from arrayType.
+   */
+  static _expandFillAllForArrayType(initValue, arrayTypeCtx) {
+    const declaredSize = _StringDeclHelper._getArrayTypeDeclaredSize(arrayTypeCtx);
+    return _StringDeclHelper._expandFillAll(initValue, declaredSize);
+  }
+  /**
+   * Common fill-all expansion logic shared between arrayType and arrayDimension paths.
+   */
+  static _expandFillAll(initValue, declaredSize) {
+    const fillVal = CodeGenState.lastArrayFillValue;
+    if (fillVal === void 0) {
+      return initValue;
+    }
+    if (fillVal === '""') {
+      return initValue;
+    }
+    if (declaredSize === null) {
+      return initValue;
+    }
+    const elements = new Array(declaredSize).fill(fillVal);
+    return `{${elements.join(", ")}}`;
+  }
+  /**
+   * Parse a numeric size from an expression, or return null if not numeric.
+   * Shared helper to eliminate duplicate parsing logic.
+   */
+  static _parseNumericSize(expr) {
+    if (!expr) {
+      return null;
+    }
+    const sizeText = expr.getText();
+    if (!/^\d+$/.exec(sizeText)) {
+      return null;
+    }
+    return Number.parseInt(sizeText, 10);
+  }
   /**
    * Generate bounded string declaration (string<N>).
    */
@@ -126268,16 +126861,33 @@ var StringDeclHelper = class _StringDeclHelper {
         constMod
       );
     }
-    _StringDeclHelper._validateStringInit(
-      expression.getText(),
+    const exprText = expression.getText();
+    const isLiteral = _StringDeclHelper._validateStringInit(
+      exprText,
       capacity,
       callbacks
     );
-    const code = `${extern}${constMod}char ${name}[${capacity + 1}] = ${callbacks.generateExpression(expression)};`;
-    return { code, handled: true };
+    if (isLiteral) {
+      const code = `${extern}${constMod}char ${name}[${capacity + 1}] = ${callbacks.generateExpression(expression)};`;
+      return { code, handled: true };
+    }
+    if (!CodeGenState.inFunctionBody) {
+      throw new Error(
+        `Error: String initialization from variable cannot be used at global scope. Move the declaration inside a function, or use an empty initializer and assign later.`
+      );
+    }
+    const srcExpr = callbacks.generateExpression(expression);
+    const indent = FormatUtils_default.indent(CodeGenState.indentLevel);
+    const lines = [];
+    lines.push(
+      `${constMod}char ${name}[${capacity + 1}] = "";`,
+      `${indent}strcpy(${name}, ${srcExpr});`
+    );
+    return { code: lines.join("\n"), handled: true };
   }
   /**
    * Validate string initialization (literal length and variable capacity)
+   * Returns true if the expression is a string literal, false if it's a variable.
    */
   static _validateStringInit(exprText, capacity, callbacks) {
     if (exprText.startsWith('"') && exprText.endsWith('"')) {
@@ -126287,6 +126897,7 @@ var StringDeclHelper = class _StringDeclHelper {
           `Error: String literal (${content} chars) exceeds string<${capacity}> capacity`
         );
       }
+      return true;
     }
     const srcCapacity = callbacks.getStringExprCapacity(exprText);
     if (srcCapacity !== null && srcCapacity > capacity) {
@@ -126294,6 +126905,7 @@ var StringDeclHelper = class _StringDeclHelper {
         `Error: Cannot assign string<${srcCapacity}> to string<${capacity}> (potential truncation)`
       );
     }
+    return false;
   }
   /**
    * Generate string array declaration.
@@ -126381,35 +126993,19 @@ var StringDeclHelper = class _StringDeclHelper {
   /**
    * Expand fill-all syntax if needed.
    * ["Hello"*] with size 3 -> {"Hello", "Hello", "Hello"}
+   * Delegates to the common fill-all expansion logic with size from arrayDimension.
    */
   static _expandFillAllIfNeeded(initValue, arrayDims) {
-    const fillVal = CodeGenState.lastArrayFillValue;
-    if (fillVal === void 0) {
-      return initValue;
-    }
-    if (fillVal === '""') {
-      return initValue;
-    }
     const declaredSize = _StringDeclHelper._getFirstDimNumericSize(arrayDims);
-    if (declaredSize === null) {
-      return initValue;
-    }
-    const elements = new Array(declaredSize).fill(fillVal);
-    return `{${elements.join(", ")}}`;
+    return _StringDeclHelper._expandFillAll(initValue, declaredSize);
   }
   /**
    * Get the numeric size from the first array dimension, or null if not numeric.
+   * Used by arrayDimension-based string arrays (string<N> arr[M]).
    */
   static _getFirstDimNumericSize(arrayDims) {
     const firstDimExpr = arrayDims[0]?.expression();
-    if (!firstDimExpr) {
-      return null;
-    }
-    const sizeText = firstDimExpr.getText();
-    if (!/^\d+$/.exec(sizeText)) {
-      return null;
-    }
-    return Number.parseInt(sizeText, 10);
+    return _StringDeclHelper._parseNumericSize(firstDimExpr);
   }
   /**
    * Generate string concatenation declaration.
@@ -126603,24 +127199,14 @@ var VariableDeclHelper = class _VariableDeclHelper {
     if (arrayDims.length === 0) {
       return;
     }
-    if (typeCtx.arrayType()) {
-      return;
-    }
-    if (arrayDims.length === 1 && !arrayDims[0].expression()) {
-      return;
-    }
-    if (arrayDims.length > 1) {
-      return;
-    }
-    if (typeCtx.qualifiedType() || typeCtx.scopedType() || typeCtx.globalType() || typeCtx.stringType()) {
-      return;
-    }
     const baseType = _VariableDeclHelper.extractBaseTypeName(typeCtx);
-    const dimensions = arrayDims.map((dim) => `[${dim.expression()?.getText() ?? ""}]`).join("");
+    const existingDims = typeCtx.arrayType() ? typeCtx.arrayType().arrayTypeDimension().map((d) => `[${d.expression()?.getText() ?? ""}]`).join("") : "";
+    const trailingDims = arrayDims.map((dim) => `[${dim.expression()?.getText() ?? ""}]`).join("");
+    const allDims = existingDims + trailingDims;
     const line = ctx.start?.line ?? 0;
     const col = ctx.start?.column ?? 0;
     throw new Error(
-      `${line}:${col} C-style array declaration is not allowed. Use '${baseType}${dimensions} ${name}' instead of '${baseType} ${name}${dimensions}'`
+      `${line}:${col} C-style array declaration is not allowed. Use '${baseType}${allDims} ${name}' instead of '${baseType}${existingDims} ${name}${trailingDims}'`
     );
   }
   /**
@@ -126727,7 +127313,8 @@ ${assignments}`;
       typeCtx,
       callbacks
     );
-    const hasEmptyArrayDim = arrayDims.some((dim) => !dim.expression());
+    const hasEmptyArrayDim = arrayDims.some((dim) => !dim.expression()) || (typeCtx.arrayType()?.arrayTypeDimension().some((dim) => !dim.expression()) ?? false);
+    const hasEmptyArrayTypeDim = typeCtx.arrayType()?.arrayTypeDimension().some((dim) => !dim.expression()) ?? false;
     const declaredSize = _VariableDeclHelper.parseArrayTypeDimension(typeCtx) ?? _VariableDeclHelper.parseFirstArrayDimension(arrayDims);
     if (ctx.expression()) {
       const arrayInitResult = ArrayInitHelper_default.processArrayInit(
@@ -126745,7 +127332,7 @@ ${assignments}`;
       );
       if (arrayInitResult) {
         CodeGenState.localArrays.add(name);
-        const fullDimSuffix = arrayTypeDimStr + arrayInitResult.dimensionSuffix;
+        const fullDimSuffix = hasEmptyArrayTypeDim ? arrayInitResult.dimensionSuffix : arrayTypeDimStr + arrayInitResult.dimensionSuffix;
         return {
           handled: true,
           code: `${decl}${fullDimSuffix} = ${arrayInitResult.initValue};`,
@@ -126780,7 +127367,9 @@ ${assignments}`;
       getExpressionType: callbacks.getExpressionType
     });
     return CodeGenState.withExpectedType(typeName, () => {
-      let exprCode = callbacks.generateExpression(ctx.expression());
+      let exprCode = CodeGenState.withDeclarationInit(
+        () => callbacks.generateExpression(ctx.expression())
+      );
       const exprType = callbacks.getExpressionType(ctx.expression());
       if (exprType && NarrowingCastHelper_default.isCrossTypeCategoryConversion(exprType, typeName)) {
         if (NarrowingCastHelper_default.isIntegerType(exprType) && NarrowingCastHelper_default.isFloatType(typeName)) {
@@ -127568,31 +128157,29 @@ var TypeGenerationHelper = class _TypeGenerationHelper {
     return "char";
   }
   /**
-   * Full type generation using all dependencies.
-   * This is the main entry point that handles all type contexts.
+   * Dispatch type generation for contexts that share common type accessors.
+   * Handles scoped, qualified, global, primitive, string, and user types.
+   * Used by both bare type contexts and array element type contexts.
+   *
+   * @returns The resolved C type string, or null if no matching type accessor found
    */
-  static generate(ctx, deps) {
-    if (ctx.primitiveType()) {
-      const type = ctx.primitiveType().getText();
-      const result = _TypeGenerationHelper.generatePrimitiveType(type);
-      return result.cType;
-    }
-    if (ctx.stringType()) {
+  static dispatchTypeGeneration(accessors, deps) {
+    if (accessors.stringType()) {
       return _TypeGenerationHelper.generateStringType();
     }
-    if (ctx.scopedType()) {
-      const typeName = ctx.scopedType().IDENTIFIER().getText();
+    if (accessors.scopedType()) {
+      const typeName = accessors.scopedType().IDENTIFIER().getText();
       return _TypeGenerationHelper.generateScopedType(
         typeName,
         deps.currentScope
       );
     }
-    if (ctx.globalType()) {
-      const typeName = ctx.globalType().IDENTIFIER().getText();
+    if (accessors.globalType()) {
+      const typeName = accessors.globalType().IDENTIFIER().getText();
       return _TypeGenerationHelper.generateGlobalType(typeName);
     }
-    if (ctx.qualifiedType()) {
-      const identifiers = ctx.qualifiedType().IDENTIFIER();
+    if (accessors.qualifiedType()) {
+      const identifiers = accessors.qualifiedType().IDENTIFIER();
       const identifierNames = identifiers.map((id) => id.getText());
       const isCpp = deps.isCppScopeSymbol(identifierNames[0]);
       return _TypeGenerationHelper.generateQualifiedType(
@@ -127601,24 +128188,36 @@ var TypeGenerationHelper = class _TypeGenerationHelper {
         deps.validateCrossScopeVisibility
       );
     }
-    if (ctx.userType()) {
-      const typeName = ctx.userType().getText();
+    if (accessors.primitiveType()) {
+      const type = accessors.primitiveType().getText();
+      return TYPE_MAP_default[type] || type;
+    }
+    if (accessors.userType()) {
+      const typeName = accessors.userType().getText();
+      if (typeName === "cstring") {
+        return "char*";
+      }
       const needsStruct = deps.checkNeedsStructKeyword(typeName);
       return _TypeGenerationHelper.generateUserType(typeName, needsStruct);
     }
+    return null;
+  }
+  /**
+   * Full type generation using all dependencies.
+   * This is the main entry point that handles all type contexts.
+   */
+  static generate(ctx, deps) {
     if (ctx.arrayType()) {
       const arrCtx = ctx.arrayType();
-      if (arrCtx.stringType()) {
-        return "char";
-      }
-      const primitiveText = arrCtx.primitiveType()?.getText() ?? null;
-      const userTypeName = arrCtx.userType()?.getText() ?? null;
-      const needsStruct = userTypeName ? deps.checkNeedsStructKeyword(userTypeName) : false;
-      return _TypeGenerationHelper.generateArrayBaseType(
-        primitiveText,
-        userTypeName,
-        needsStruct
-      );
+      const result2 = _TypeGenerationHelper.dispatchTypeGeneration(arrCtx, deps);
+      if (result2 !== null) {
+        return result2;
+      }
+      return ctx.getText();
+    }
+    const result = _TypeGenerationHelper.dispatchTypeGeneration(ctx, deps);
+    if (result !== null) {
+      return result;
     }
     if (ctx.getText() === "void") {
       return "void";
@@ -128979,6 +129578,7 @@ var ParameterInputAdapter = class {
     const isKnownStruct = deps.isKnownStruct(typeName);
     const isKnownPrimitive = !!deps.typeMap[typeName];
     const isTypedefStruct = deps.isTypedefStructType(typeName);
+    const isOpaque = deps.isOpaqueType?.(typeName) ?? false;
     const isAutoConst = !deps.isCallbackCompatible && !deps.isModified && !isConst;
     const isPassByReference = deps.forcePassByReference || isKnownStruct || isKnownPrimitive || isTypedefStruct;
     return {
@@ -128996,7 +129596,9 @@ var ParameterInputAdapter = class {
       // and typedef struct params (C types expect pointers, not C++ references)
       forcePointerSyntax: deps.forcePassByReference || isTypedefStruct || void 0,
       // Issue #895: Preserve const from callback typedef signature
-      forceConst: deps.forceConst
+      forceConst: deps.forceConst,
+      // Issue #995: Pass through opaque handle detection — rule applied in builder
+      isOpaqueHandle: isOpaque || void 0
     };
   }
   /**
@@ -129043,7 +129645,9 @@ var ParameterInputAdapter = class {
       isPassByValue: isCallbackPointer ? false : deps.isPassByValue,
       isPassByReference: isCallbackPointer ? true : !deps.isPassByValue,
       forcePointerSyntax: isCallbackPointer || void 0,
-      forceConst: param.isCallbackConst || void 0
+      forceConst: param.isCallbackConst || void 0,
+      // Issue #995: Pass through opaque handle detection — rule applied in builder
+      isOpaqueHandle: param.isOpaqueHandle || void 0
     };
   }
   /**
@@ -129085,13 +129689,12 @@ var ParameterInputAdapter = class {
         dims.push(String(capacity + 1));
       }
     }
-    const isAutoConst = !deps.isModified && !isConst;
     return {
       name,
       baseType: typeName,
       mappedType,
       isConst,
-      isAutoConst,
+      isAutoConst: false,
       isArray: true,
       arrayDimensions: dims,
       isCallback: false,
@@ -129169,6 +129772,9 @@ var ParameterSignatureBuilder = class {
     if (param.isString && !param.isArray) {
       return this._buildStringParam(param);
     }
+    if (param.isOpaqueHandle) {
+      return this._buildRefParam(param, refSuffix);
+    }
     if (param.isPassByReference) {
       return this._buildRefParam(param, refSuffix);
     }
@@ -129213,14 +129819,16 @@ var ParameterSignatureBuilder = class {
   /**
    * Build pass-by-reference parameter signature.
    * C mode: const Point* p
-   * C++ mode: const Point& p (unless forcePointerSyntax)
+   * C++ mode: const Point& p (unless forcePointerSyntax or isOpaqueHandle)
    *
    * Issue #895: When forcePointerSyntax is set, always use pointer syntax
    * because C callback typedefs expect pointers, not C++ references.
+   * Issue #995: Opaque handles must use pointer syntax because C APIs
+   * expect pointers to incomplete struct types (e.g., widget_t*).
    */
   static _buildRefParam(param, refSuffix) {
     const constPrefix = this._getConstPrefix(param);
-    const actualSuffix = param.forcePointerSyntax ? "*" : refSuffix;
+    const actualSuffix = param.forcePointerSyntax || param.isOpaqueHandle ? "*" : refSuffix;
     return `${constPrefix}${param.mappedType}${actualSuffix} ${param.name}`;
   }
   /**
@@ -129234,9 +129842,12 @@ var ParameterSignatureBuilder = class {
    * Get const prefix combining explicit const, auto-const, and forced const.
    * Priority: forceConst > isConst > isAutoConst
    * Issue #895: forceConst preserves const from callback typedef signature.
+   * Issue #995: Opaque handles suppress auto-const (they must be passed to
+   * C APIs that expect non-const pointers).
    */
   static _getConstPrefix(param) {
-    if (param.forceConst || param.isConst || param.isAutoConst) {
+    const effectiveAutoConst = param.isOpaqueHandle ? false : param.isAutoConst;
+    if (param.forceConst || param.isConst || effectiveAutoConst) {
       return "const ";
     }
     return "";
@@ -129833,6 +130444,7 @@ var CodeGenerator = class _CodeGenerator {
    * Part of IOrchestrator interface.
    * ADR-045: Used to detect string comparisons and generate strcmp().
    * Issue #137: Extended to handle array element access (e.g., names[0])
+   * Issue #1030: Extended to handle struct member access (e.g., person.name)
    */
   isStringExpression(ctx) {
     const text = ctx.getText();
@@ -129845,6 +130457,9 @@ var CodeGenerator = class _CodeGenerator {
         return true;
       }
     }
+    if (this._isStructMemberStringExpression(text)) {
+      return true;
+    }
     return this._isArrayAccessStringExpression(text);
   }
   /**
@@ -129872,6 +130487,36 @@ var CodeGenerator = class _CodeGenerator {
       typeInfo.isArray && typeInfo.baseType && TypeCheckUtils_default.isString(typeInfo.baseType)
     );
   }
+  /**
+   * Check if struct member access expression evaluates to a string.
+   * Issue #1030: Handles patterns like person.name, config.key
+   */
+  _isStructMemberStringExpression(text) {
+    if (text.endsWith(".char_count") || text.endsWith(".capacity") || text.endsWith(".size") || text.endsWith(".length") || text.endsWith(".bit_length") || text.endsWith(".byte_length") || text.endsWith(".element_count")) {
+      return false;
+    }
+    const memberMatch = /^([a-zA-Z_]\w*)\.([a-zA-Z_]\w*)$/.exec(text);
+    if (!memberMatch) {
+      return false;
+    }
+    const [, varName, fieldName] = memberMatch;
+    const typeInfo = CodeGenState.getVariableTypeInfo(varName);
+    if (!typeInfo) {
+      return false;
+    }
+    const structTypeName = typeInfo.baseType;
+    if (!structTypeName) {
+      return false;
+    }
+    const fieldType = CodeGenState.getStructFieldType(
+      structTypeName,
+      fieldName
+    );
+    if (!fieldType) {
+      return false;
+    }
+    return fieldType.startsWith("string");
+  }
   /**
    * Get type of additive expression.
    * Part of IOrchestrator interface - delegates to private implementation.
@@ -130269,21 +130914,21 @@ var CodeGenerator = class _CodeGenerator {
    */
   getZeroInitializer(typeCtx, isArray) {
     if (isArray) {
-      return this._getArrayZeroInitializer(typeCtx);
+      return this._getAggregateZeroInitBrace();
     }
     const resolved = this._resolveTypeNameFromContext(typeCtx);
     if (resolved) {
       if (CodeGenState.symbols.knownEnums.has(resolved.name)) {
         return this._getEnumZeroValue(resolved.name, resolved.separator);
       }
-      if (resolved.checkCppType && this._needsEmptyBraceInit(resolved.name)) {
-        return "{}";
-      }
-      return "{0}";
+      return this._getAggregateZeroInitBrace();
     }
     if (typeCtx.templateType()) {
       return "{}";
     }
+    if (typeCtx.stringType()) {
+      return '""';
+    }
     if (typeCtx.primitiveType()) {
       const primType = typeCtx.primitiveType().getText();
       return _CodeGenerator.PRIMITIVE_ZERO_VALUES.get(primType) ?? "0";
@@ -130395,7 +131040,7 @@ var CodeGenerator = class _CodeGenerator {
       const constMod = p.isConst ? "const " : "";
       if (p.isArray) {
         return `${constMod}${p.type} ${p.name}${p.arrayDims}`;
-      } else if (p.isPointer) {
+      } else if (p.isStruct) {
         const ptrOrRef = this.isCppMode() ? "&" : "*";
         return `${constMod}${p.type}${ptrOrRef}`;
       } else {
@@ -130595,7 +131240,15 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
       return "__GLOBAL_PREFIX__";
     }
     if (ctx.IDENTIFIER()) {
-      return this._resolveIdentifierExpression(ctx.IDENTIFIER().getText());
+      const id = ctx.IDENTIFIER().getText();
+      if (id === "break" || id === "continue") {
+        const line = ctx.start?.line ?? 0;
+        const col = ctx.start?.column ?? 0;
+        throw new Error(
+          `${line}:${col} error[E0703]: '${id}' is not supported in C-Next - use structured conditions instead`
+        );
+      }
+      return this._resolveIdentifierExpression(id);
     }
     if (ctx.literal()) {
       return this._generateLiteralExpression(ctx.literal());
@@ -130840,14 +131493,6 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
     }
     return identifiers.join("_");
   }
-  /**
-   * Issue #304: Check if a type name is from a C++ header
-   * Used to determine whether to use {} or {0} for initialization.
-   * C++ types with constructors may fail with {0} but work with {}.
-   */
-  isCppType(typeName) {
-    return SymbolLookupHelper_default.isCppType(CodeGenState.symbolTable, typeName);
-  }
   /**
    * Generate C code from a C-Next program
    * @param tree The parsed C-Next program
@@ -131278,6 +131923,7 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
         const arrayTypeCtx = param.type().arrayType();
         const isArray = dims.length > 0 || arrayTypeCtx !== null;
         const isCallbackParam = CodeGenState.callbackTypes.has(typeName);
+        const isStruct = this.isStructType(typeName);
         let paramType;
         let isPointer;
         if (isCallbackParam) {
@@ -131286,7 +131932,7 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
           isPointer = false;
         } else {
           paramType = this.generateType(param.type());
-          isPointer = !isArray;
+          isPointer = !isArray && isStruct;
         }
         let arrayDims;
         if (dims.length > 0) {
@@ -131304,6 +131950,7 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
           type: paramType,
           isConst,
           isPointer,
+          isStruct,
           isArray,
           arrayDims
         });
@@ -131649,7 +132296,7 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
     }
     decl += this._getStringCapacityDimension(varDecl.type());
     if (varDecl.expression()) {
-      decl += ` = ${this.generateExpression(varDecl.expression())}`;
+      decl += ` = ${CodeGenState.withDeclarationInit(() => this.generateExpression(varDecl.expression()))}`;
     } else {
       decl += ` = ${this.getZeroInitializer(varDecl.type(), isArray)}`;
     }
@@ -131842,21 +132489,13 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
       needsStructKeyword
     );
     if (!fieldList) {
-      return isCppClass ? "{}" : `(${castType}){ 0 }`;
+      if (isCppClass) return "{}";
+      return CodeGenState.inDeclarationInit ? "{ 0 }" : `(${castType}){ 0 }`;
     }
     const structFieldTypes = CodeGenState.symbolTable?.getStructFieldTypes(typeName);
     const fields = fieldList.fieldInitializer().map((field) => {
       const fieldName = field.IDENTIFIER().getText();
-      let fieldType;
-      if (structFieldTypes?.has(fieldName)) {
-        fieldType = structFieldTypes.get(fieldName);
-        if (fieldType.includes("_")) {
-          const parts = fieldType.split("_");
-          if (parts.length > 1 && this.isCppScopeSymbol(parts[0])) {
-            fieldType = parts.join("::");
-          }
-        }
-      }
+      const fieldType = this._resolveFieldType(fieldName, structFieldTypes);
       const value = CodeGenState.withExpectedType(
         fieldType,
         () => this.generateExpression(field.expression())
@@ -131872,10 +132511,35 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
       return "{}";
     }
     const fieldInits = fields.map((f) => `.${f.fieldName} = ${f.value}`);
+    return this.formatStructInitializer(typeName, castType, fieldInits);
+  }
+  formatStructInitializer(typeName, castType, fieldInits) {
+    const initializer = `{ ${fieldInits.join(", ")} }`;
+    if (CodeGenState.inDeclarationInit) {
+      return initializer;
+    }
     if (CodeGenState.cppMode && (typeName.startsWith("struct {") || typeName.startsWith("union {"))) {
-      return `{ ${fieldInits.join(", ")} }`;
+      return initializer;
+    }
+    if (!CodeGenState.inFunctionBody) {
+      return initializer;
     }
-    return `(${castType}){ ${fieldInits.join(", ")} }`;
+    return `(${castType})${initializer}`;
+  }
+  /**
+   * Resolve the C type string for a named struct field, converting C++ underscore-separated
+   * names to :: notation. Returns undefined if the field is not in the type map.
+   * Issue #502: C-Next stores C++ types with _ separator; codegen needs ::.
+   */
+  _resolveFieldType(fieldName, structFieldTypes) {
+    if (!structFieldTypes?.has(fieldName)) return void 0;
+    const fieldType = structFieldTypes.get(fieldName);
+    if (!fieldType.includes("_")) return fieldType;
+    const parts = fieldType.split("_");
+    if (parts.length > 1 && this.isCppScopeSymbol(parts[0])) {
+      return parts.join("::");
+    }
+    return fieldType;
   }
   /**
    * ADR-035: Generate array initializer
@@ -132018,7 +132682,9 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
       isCallbackCompatible,
       forcePassByReference,
       forceConst,
-      isTypedefStructType: (t) => CodeGenState.symbolTable?.isTypedefStructType(t) ?? false
+      isTypedefStructType: (t) => CodeGenState.symbolTable?.isTypedefStructType(t) ?? false,
+      // Issue #995: Opaque handles should not get auto-const
+      isOpaqueType: (t) => CodeGenState.isOpaqueType(t)
     });
     return ParameterSignatureBuilder_default.build(input, CppModeHelper_default.refOrPtr());
   }
@@ -132249,26 +132915,13 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
   // _generateVariableInitializer, _validateIntegerInitializer, _finalizeCppClassAssignments,
   // and _generateConstructorDecl have been extracted to VariableDeclHelper.ts
   /**
-   * Get zero initializer for array types.
-   * Issue #379: C++ class arrays must use {} instead of {0}
+   * Brace initializer that zero-initializes an aggregate (struct or array).
+   * Issue #379 / #1004: C++ uses value-initialization ({}), which is valid for
+   * any aggregate element type (POD, struct, class) including enum-first
+   * structs where {0} is an invalid int->enum narrowing; C uses {0}.
    */
-  _getArrayZeroInitializer(typeCtx) {
-    if (typeCtx.userType()) {
-      const typeName = typeCtx.userType().getText();
-      if (this._needsEmptyBraceInit(typeName)) {
-        return "{}";
-      }
-    }
-    if (typeCtx.arrayType()?.userType()) {
-      const typeName = typeCtx.arrayType().userType().getText();
-      if (this._needsEmptyBraceInit(typeName)) {
-        return "{}";
-      }
-    }
-    if (typeCtx.templateType()) {
-      return "{}";
-    }
-    return "{0}";
+  _getAggregateZeroInitBrace() {
+    return CodeGenState.cppMode ? "{}" : "{0}";
   }
   /**
    * Get zero initializer for an enum type.
@@ -132293,49 +132946,35 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
   }
   /**
    * Resolve full type name from any TypeContext variant.
-   * Returns { name, separator, checkCppType } or null if not a named type.
+   * Returns { name, separator } or null if not a named type.
    * ADR-016: Handles scoped, global, qualified, and user types
-   * checkCppType: only true for userType (original behavior preserved)
    */
   _resolveTypeNameFromContext(typeCtx) {
     if (typeCtx.scopedType()) {
       const localName = typeCtx.scopedType().IDENTIFIER().getText();
       const name = CodeGenState.currentScope ? `${CodeGenState.currentScope}_${localName}` : localName;
-      return { name, separator: "_", checkCppType: false };
+      return { name, separator: "_" };
     }
     if (typeCtx.globalType()) {
       return {
         name: typeCtx.globalType().IDENTIFIER().getText(),
-        separator: "_",
-        checkCppType: false
+        separator: "_"
       };
     }
     if (typeCtx.qualifiedType()) {
       const parts = typeCtx.qualifiedType().IDENTIFIER();
       const name = this.resolveQualifiedType(parts.map((id) => id.getText()));
       const separator = name.includes("::") ? "::" : "_";
-      return { name, separator, checkCppType: false };
+      return { name, separator };
     }
     if (typeCtx.userType()) {
       return {
         name: typeCtx.userType().getText(),
-        separator: "_",
-        checkCppType: true
+        separator: "_"
       };
     }
     return null;
   }
-  /**
-   * Check if a type needs empty brace initialization {}.
-   * Issue #304: C++ types with constructors may fail with {0}
-   * Issue #309: Unknown user types in C++ mode may have non-trivial constructors
-   */
-  _needsEmptyBraceInit(typeName) {
-    if (this.isCppType(typeName)) {
-      return true;
-    }
-    return CodeGenState.cppMode && !this.isKnownStruct(typeName);
-  }
   /**
    * Generate a safe bit mask expression.
    * Avoids undefined behavior when width >= 32 for 32-bit integers.
@@ -132715,7 +133354,7 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
     const maxComparison = `((${floatCastType})${maxValue})`;
     const finalCast = CppModeHelper_default.cast(targetType, `(${expr})`);
     const castMax = CppModeHelper_default.cast(targetType, maxValue);
-    const castMin = minValue === "0" ? "0" : CppModeHelper_default.cast(targetType, minValue);
+    const castMin = CppModeHelper_default.cast(targetType, minValue);
     return `((${expr}) > ${maxComparison} ? ${castMax} : (${expr}) < ${minComparison} ? ${castMin} : ${finalCast})`;
   }
   /**
@@ -133091,6 +133730,30 @@ var generateEnumHeader_default = generateEnumHeader;
 
 // src/transpiler/output/headers/generators/generateStructHeader.ts
 var { mapType: mapType2 } = mapType_default;
+function resolveFieldCType(fieldType, input) {
+  const callbackInfo = input.callbackTypes?.get(fieldType);
+  if (callbackInfo) {
+    return callbackInfo.typedefName;
+  }
+  const convertedType = CppNamespaceUtils_default.convertToCppNamespace(
+    fieldType,
+    input.symbolTable
+  );
+  return mapType2(convertedType);
+}
+function generateFieldLine(fieldName, cType, dims) {
+  const dimSuffix = dims && dims.length > 0 ? dims.map((d) => `[${d}]`).join("") : "";
+  const embeddedMatch = /^(\w+)\[(\d+)\]$/.exec(cType);
+  if (!embeddedMatch) {
+    return `    ${cType} ${fieldName}${dimSuffix};`;
+  }
+  const baseType = embeddedMatch[1];
+  const embeddedDim = embeddedMatch[2];
+  if (dims && dims.length > 0) {
+    return `    ${baseType} ${fieldName}${dimSuffix};`;
+  }
+  return `    ${baseType} ${fieldName}[${embeddedDim}];`;
+}
 function generateStructHeader(name, input) {
   const fields = input.structFields.get(name);
   if (!fields || fields.size === 0) {
@@ -133100,25 +133763,9 @@ function generateStructHeader(name, input) {
   const lines = [];
   lines.push(`typedef struct ${name} {`);
   for (const [fieldName, fieldType] of fields) {
-    const convertedType = CppNamespaceUtils_default.convertToCppNamespace(
-      fieldType,
-      input.symbolTable
-    );
-    const cType = mapType2(convertedType);
+    const cType = resolveFieldCType(fieldType, input);
     const dims = dimensions?.get(fieldName);
-    const dimSuffix = dims && dims.length > 0 ? dims.map((d) => `[${d}]`).join("") : "";
-    const embeddedMatch = /^(\w+)\[(\d+)\]$/.exec(cType);
-    if (embeddedMatch) {
-      const baseType = embeddedMatch[1];
-      const embeddedDim = embeddedMatch[2];
-      if (dims && dims.length > 0) {
-        lines.push(`    ${baseType} ${fieldName}${dimSuffix};`);
-      } else {
-        lines.push(`    ${baseType} ${fieldName}[${embeddedDim}];`);
-      }
-    } else {
-      lines.push(`    ${cType} ${fieldName}${dimSuffix};`);
-    }
+    lines.push(generateFieldLine(fieldName, cType, dims));
   }
   lines.push(`} ${name};`);
   return lines.join("\n");
@@ -133511,6 +134158,59 @@ var HeaderGeneratorUtils = class _HeaderGeneratorUtils {
     lines.push("");
     return lines;
   }
+  /**
+   * ADR-029: Generate forward declarations for structs used in callback typedefs.
+   * This ensures struct types can be used in callback parameter types before
+   * the full struct definition.
+   */
+  static generateCallbackStructForwardDecls(structs, typeInput) {
+    if (!typeInput?.callbackTypes || typeInput.callbackTypes.size === 0) {
+      return [];
+    }
+    const usedStructTypes = /* @__PURE__ */ new Set();
+    for (const [, cbInfo] of typeInput.callbackTypes) {
+      for (const p of cbInfo.parameters) {
+        if (p.isStruct) {
+          usedStructTypes.add(p.type);
+        }
+      }
+    }
+    if (usedStructTypes.size === 0) {
+      return [];
+    }
+    const localStructNames = new Set(structs.map((s) => s.name));
+    const lines = [];
+    for (const structType of usedStructTypes) {
+      if (localStructNames.has(structType)) {
+        lines.push(`typedef struct ${structType} ${structType};`);
+      }
+    }
+    return lines.length > 0 ? [...lines, ""] : [];
+  }
+  /**
+   * ADR-029: Generate callback typedef section
+   * Generates function pointer typedefs for callbacks used as struct field types
+   */
+  static generateCallbackTypedefSection(typeInput, isCppMode) {
+    if (!typeInput?.callbackTypes || typeInput.callbackTypes.size === 0) {
+      return [];
+    }
+    const lines = ["/* Callback typedefs */"];
+    for (const [, cbInfo] of typeInput.callbackTypes) {
+      const params = cbInfo.parameters.length > 0 ? cbInfo.parameters.map((p) => {
+        if (p.isStruct) {
+          const ptrOrRef = isCppMode ? "&" : "*";
+          return `${p.type}${ptrOrRef}`;
+        }
+        return p.type;
+      }).join(", ") : "void";
+      lines.push(
+        `typedef ${cbInfo.returnType} (*${cbInfo.typedefName})(${params});`
+      );
+    }
+    lines.push("");
+    return lines;
+  }
   /**
    * Generate struct and class definitions section
    */
@@ -133638,6 +134338,14 @@ var BaseHeaderGenerator = class {
       ...HeaderGeneratorUtils_default.generateEnumSection(groups.enums, typeInput),
       ...HeaderGeneratorUtils_default.generateBitmapSection(groups.bitmaps, typeInput),
       ...HeaderGeneratorUtils_default.generateTypeAliasSection(groups.types),
+      ...HeaderGeneratorUtils_default.generateCallbackStructForwardDecls(
+        groups.structs,
+        typeInput
+      ),
+      ...HeaderGeneratorUtils_default.generateCallbackTypedefSection(
+        typeInput,
+        options.cppMode
+      ),
       ...HeaderGeneratorUtils_default.generateStructSection(
         groups.structs,
         groups.classes,
@@ -133976,24 +134684,32 @@ var EnumCollector = class {
 var EnumCollector_default = EnumCollector;
 
 // src/transpiler/logic/symbols/cnext/utils/TypeUtils.ts
-function resolveScopedType(scopedTypeCtx, scopeName) {
-  const typeName = scopedTypeCtx.IDENTIFIER().getText();
-  return scopeName ? `${scopeName}_${typeName}` : typeName;
-}
 function resolveStringType(stringCtx) {
   const intLiteral = stringCtx.INTEGER_LITERAL();
   return intLiteral ? `string<${intLiteral.getText()}>` : "string";
 }
-function resolveArrayInnerType(arrayTypeCtx) {
-  if (arrayTypeCtx.primitiveType()) {
-    return arrayTypeCtx.primitiveType().getText();
+function dispatchTypeResolution(accessors, scopeName) {
+  if (accessors.scopedType()) {
+    const typeName = accessors.scopedType().IDENTIFIER().getText();
+    return scopeName ? `${scopeName}_${typeName}` : typeName;
+  }
+  if (accessors.globalType()) {
+    return accessors.globalType().IDENTIFIER().getText();
   }
-  if (arrayTypeCtx.userType()) {
-    return arrayTypeCtx.userType().getText();
+  if (accessors.qualifiedType()) {
+    const identifiers = accessors.qualifiedType().IDENTIFIER();
+    return identifiers.map((id) => id.getText()).join("_");
   }
-  const text = arrayTypeCtx.getText();
-  const bracketIdx = text.indexOf("[");
-  return bracketIdx > 0 ? text.substring(0, bracketIdx) : text;
+  if (accessors.userType()) {
+    return accessors.userType().getText();
+  }
+  if (accessors.primitiveType()) {
+    return accessors.primitiveType().getText();
+  }
+  if (accessors.stringType()) {
+    return resolveStringType(accessors.stringType());
+  }
+  return null;
 }
 var TypeUtils = class {
   /**
@@ -134007,27 +134723,18 @@ var TypeUtils = class {
    */
   static getTypeName(ctx, scopeName) {
     if (!ctx) return "void";
-    if (ctx.scopedType()) {
-      return resolveScopedType(ctx.scopedType(), scopeName);
-    }
-    if (ctx.globalType()) {
-      return ctx.globalType().IDENTIFIER().getText();
-    }
-    if (ctx.qualifiedType()) {
-      const identifiers = ctx.qualifiedType().IDENTIFIER();
-      return identifiers.map((id) => id.getText()).join("_");
-    }
-    if (ctx.userType()) {
-      return ctx.userType().getText();
-    }
-    if (ctx.primitiveType()) {
-      return ctx.primitiveType().getText();
-    }
-    if (ctx.stringType()) {
-      return resolveStringType(ctx.stringType());
-    }
     if (ctx.arrayType()) {
-      return resolveArrayInnerType(ctx.arrayType());
+      const result2 = dispatchTypeResolution(ctx.arrayType(), scopeName);
+      if (result2 !== null) {
+        return result2;
+      }
+      const text = ctx.arrayType().getText();
+      const bracketIdx = text.indexOf("[");
+      return bracketIdx > 0 ? text.substring(0, bracketIdx) : text;
+    }
+    const result = dispatchTypeResolution(ctx, scopeName);
+    if (result !== null) {
+      return result;
     }
     return ctx.getText();
   }
@@ -134393,13 +135100,22 @@ var VariableCollector = class _VariableCollector {
     return dimensions;
   }
   /**
-   * Collect dimensions from C-Next style arrayType syntax (u16[8] arr, u16[4][4] arr).
+   * Collect dimensions from C-Next style arrayType syntax (u16[8] arr, u16[4][4] arr, u16[] arr).
+   * Handles size inference from initializer when dimension is empty.
    */
-  static collectArrayTypeDimensions(arrayTypeCtx, constValues) {
+  static collectArrayTypeDimensions(arrayTypeCtx, constValues, initExpr) {
     const dimensions = [];
     for (const dim of arrayTypeCtx.arrayTypeDimension()) {
       const sizeExpr = dim.expression();
-      if (!sizeExpr) continue;
+      if (!sizeExpr) {
+        if (initExpr) {
+          const inferredSize = ArrayInitializerUtils_default.getInferredSize(initExpr);
+          if (inferredSize !== void 0) {
+            dimensions.push(inferredSize);
+          }
+        }
+        continue;
+      }
       const dimText = sizeExpr.getText();
       const literalSize = LiteralUtils_default.parseIntegerLiteral(dimText);
       if (literalSize !== void 0) {
@@ -134441,7 +135157,8 @@ var VariableCollector = class _VariableCollector {
       arrayDimensions.push(
         ..._VariableCollector.collectArrayTypeDimensions(
           arrayTypeCtx,
-          constValues
+          constValues,
+          initExpr
         )
       );
     }
@@ -134560,7 +135277,9 @@ var ScopeCollector = class {
     const memberSymbols = [];
     for (const member of ctx.scopeMember()) {
       const visibilityMod = member.visibilityModifier();
-      const visibility = visibilityMod?.getText() ?? "private";
+      const explicitVisibility = visibilityMod?.getText();
+      const isFunction = member.functionDeclaration() !== null;
+      const visibility = explicitVisibility ?? ScopeUtils_default.getDefaultVisibility(isFunction);
       const isPublic = visibility === "public";
       if (member.variableDeclaration()) {
         const varDecl = member.variableDeclaration();
@@ -135250,12 +135969,15 @@ var TSymbolInfoAdapter_default = TSymbolInfoAdapter;
 var RESERVED_FIELD_NAMES = /* @__PURE__ */ new Set([]);
 function parseArrayDimensions2(text) {
   const dimensions = [];
-  const arrayMatches = text.match(/\[(\d+)\]/g);
+  const arrayMatches = text.match(/\[([^\]]+)\]/g);
   if (arrayMatches) {
     for (const match of arrayMatches) {
-      const size = Number.parseInt(match.slice(1, -1), 10);
-      if (!Number.isNaN(size)) {
-        dimensions.push(size);
+      const content = match.slice(1, -1).trim();
+      const numericValue = Number.parseInt(content, 10);
+      if (!Number.isNaN(numericValue) && String(numericValue) === content) {
+        dimensions.push(numericValue);
+      } else {
+        dimensions.push(content);
       }
     }
   }
@@ -135453,6 +136175,7 @@ var DeclaratorUtils = class _DeclaratorUtils {
   }
   /**
    * Extract array dimensions from a declarator.
+   * Issue #981: Returns (number | string)[] to support macro-sized arrays.
    */
   static extractArrayDimensions(declarator) {
     const directDecl = declarator.directDeclarator?.();
@@ -136607,6 +137330,7 @@ var DeclaratorUtils2 = class _DeclaratorUtils {
   }
   /**
    * Extract array dimensions from a declarator.
+   * Issue #981: Returns (number | string)[] to support macro-sized arrays.
    */
   static extractArrayDimensions(declarator) {
     const ptrDecl = declarator.pointerDeclarator?.();
@@ -136624,6 +137348,7 @@ var DeclaratorUtils2 = class _DeclaratorUtils {
   }
   /**
    * Extract array dimensions from a noPointerDeclarator.
+   * Issue #981: Returns (number | string)[] to support macro-sized arrays.
    */
   static extractArrayDimensionsFromNoPtr(noPtr) {
     return SymbolUtils_default.parseArrayDimensions(noPtr.getText());
@@ -138795,19 +139520,28 @@ var InitializationListener = class extends CNextListener {
     if (!baseId) {
       return;
     }
+    const target = this._resolveAssignmentTarget(baseId, postfixOps);
+    const isCompoundAssignment = ctx.assignmentOperator().ASSIGN() === null;
+    if (isCompoundAssignment) {
+      const { line, column } = ParserUtils_default.getPosition(ctx);
+      this.analyzer.checkRead(target.varName, line, column, target.fieldName);
+    }
+    this.analyzer.recordAssignment(target.varName, target.fieldName);
+  };
+  /**
+   * Resolve an assignment target to its variable name and optional field name.
+   * Single classification path used by both read checks and assignment recording.
+   */
+  _resolveAssignmentTarget(baseId, postfixOps) {
     if (postfixOps.length === 0) {
-      this.analyzer.recordAssignment(baseId);
-      return;
+      return { varName: baseId };
     }
     const { identifiers, hasSubscript } = PostfixAnalysisUtils_default(baseId, postfixOps);
     if (identifiers.length >= 2 && !hasSubscript) {
-      const varName = identifiers[0];
-      const fieldName = identifiers[1];
-      this.analyzer.recordAssignment(varName, fieldName);
-    } else {
-      this.analyzer.recordAssignment(baseId);
+      return { varName: identifiers[0], fieldName: identifiers[1] };
     }
-  };
+    return { varName: baseId };
+  }
   // ========================================================================
   // Function Call Arguments (ADR-006: pass-by-reference may initialize)
   // ========================================================================
@@ -139045,27 +139779,128 @@ var InitializationAnalyzer = class {
   }
   /**
    * Process scope member variable declarations (ADR-016)
+   * Issue #1019: Scope members require explicit initialization like locals
    */
   _processScopeMembers(decl) {
     const scopeDecl = decl.scopeDeclaration();
     if (!scopeDecl) return;
     const scopeName = scopeDecl.IDENTIFIER().getText();
+    const assignedMembers = this._findAssignedScopeMembers(scopeDecl);
     for (const member of scopeDecl.scopeMember()) {
-      this._processScopeMemberVariable(member, scopeName);
+      this._processScopeMemberVariable(member, scopeName, assignedMembers);
+    }
+  }
+  /**
+   * Scan all functions in a scope to find which members are assigned.
+   * Issue #1019: A member assigned in ANY function is considered initialized
+   * for reads in other functions within the same scope.
+   */
+  _findAssignedScopeMembers(scopeDecl) {
+    const assigned = /* @__PURE__ */ new Set();
+    for (const member of scopeDecl.scopeMember()) {
+      const funcDecl = member.functionDeclaration();
+      if (!funcDecl) continue;
+      const body = funcDecl.block();
+      if (!body) continue;
+      this._collectAssignmentsInBlock(body, assigned);
+    }
+    return assigned;
+  }
+  /**
+   * Recursively collect variable names that are assigned in a block.
+   * Looks for assignment statements targeting bare identifiers or this.member.
+   */
+  _collectAssignmentsInBlock(block, assigned) {
+    for (const stmt of block.statement()) {
+      this._collectAssignmentsInStatement(stmt, assigned);
+    }
+  }
+  /**
+   * Collect assignments from a single statement, recursing into nested blocks.
+   */
+  _collectAssignmentsInStatement(stmt, assigned) {
+    this._collectDirectAssignment(stmt, assigned);
+    this._collectFromControlFlow(stmt, assigned);
+    this._collectFromSwitch(stmt, assigned);
+    this._collectFromBlock(stmt, assigned);
+  }
+  /**
+   * Collect assignment from the statement itself (if it's an assignment).
+   */
+  _collectDirectAssignment(stmt, assigned) {
+    const assignStmt = stmt.assignmentStatement();
+    if (!assignStmt) return;
+    const target = assignStmt.assignmentTarget();
+    if (!target) return;
+    const id = target.IDENTIFIER()?.getText();
+    if (id) {
+      assigned.add(id);
+    }
+  }
+  /**
+   * Recurse into control flow statements (if, while, do-while, for).
+   */
+  _collectFromControlFlow(stmt, assigned) {
+    const ifStmt = stmt.ifStatement();
+    if (ifStmt) {
+      for (const childStmt of ifStmt.statement()) {
+        this._collectAssignmentsInStatement(childStmt, assigned);
+      }
+    }
+    const whileBody = stmt.whileStatement()?.statement();
+    if (whileBody) {
+      this._collectAssignmentsInStatement(whileBody, assigned);
+    }
+    const doWhileBody = stmt.doWhileStatement()?.block();
+    if (doWhileBody) {
+      this._collectAssignmentsInBlock(doWhileBody, assigned);
+    }
+    const forBody = stmt.forStatement()?.statement();
+    if (forBody) {
+      this._collectAssignmentsInStatement(forBody, assigned);
+    }
+  }
+  /**
+   * Recurse into switch statement cases.
+   */
+  _collectFromSwitch(stmt, assigned) {
+    const switchStmt = stmt.switchStatement();
+    if (!switchStmt) return;
+    for (const switchCase of switchStmt.switchCase()) {
+      const caseBlock = switchCase.block();
+      if (caseBlock) {
+        this._collectAssignmentsInBlock(caseBlock, assigned);
+      }
+    }
+    const defaultBlock = switchStmt.defaultCase()?.block();
+    if (defaultBlock) {
+      this._collectAssignmentsInBlock(defaultBlock, assigned);
+    }
+  }
+  /**
+   * Recurse into standalone block statement.
+   */
+  _collectFromBlock(stmt, assigned) {
+    const block = stmt.block();
+    if (block) {
+      this._collectAssignmentsInBlock(block, assigned);
     }
   }
   /**
    * Process a single scope member variable
    */
-  _processScopeMemberVariable(member, scopeName) {
+  _processScopeMemberVariable(member, scopeName, assignedMembers) {
     const memberVar = member.variableDeclaration();
     if (!memberVar) return;
     const varName = memberVar.IDENTIFIER().getText();
     const fullName = `${scopeName}_${varName}`;
     const { line, column } = ParserUtils_default.getPosition(memberVar);
     const typeName = this._extractUserTypeName(memberVar.type());
-    this.declareVariable(varName, line, column, true, typeName);
-    this.declareVariable(fullName, line, column, true, typeName);
+    const hasInlineInit = memberVar.expression() !== null;
+    const isAssignedInScope = assignedMembers.has(varName);
+    const hasInitializer = hasInlineInit || isAssignedInScope;
+    this.declareVariable(varName, line, column, hasInitializer, typeName);
+    this.declareVariable(fullName, line, column, hasInitializer, typeName);
   }
   /**
    * Extract user type name from a type context
@@ -139564,14 +140399,18 @@ var FunctionCallListener = class extends CNextListener {
     const primary = ctx.primaryExpression();
     const baseName = this.extractBaseName(primary);
     if (!baseName) return;
-    const { resolvedName, foundCall } = this.resolveCallTarget(ops, baseName);
+    const { resolvedName, foundCall, isGlobalCall } = this.resolveCallTarget(
+      ops,
+      baseName
+    );
     if (!foundCall) return;
     const { line, column } = ParserUtils_default.getPosition(ctx);
     this.analyzer.checkFunctionCall(
       resolvedName,
       line,
       column,
-      this.currentScope
+      this.currentScope,
+      isGlobalCall
     );
   };
   /**
@@ -139584,6 +140423,9 @@ var FunctionCallListener = class extends CNextListener {
     if (primary.THIS()) {
       return "this";
     }
+    if (primary.GLOBAL()) {
+      return "global";
+    }
     return null;
   }
   /**
@@ -139593,11 +140435,15 @@ var FunctionCallListener = class extends CNextListener {
    */
   resolveCallTarget(ops, baseName) {
     let resolvedName = baseName;
+    let isGlobalCall = baseName === "global";
     for (const op of ops) {
       if (op.IDENTIFIER()) {
         const resolved = this.resolveMemberAccess(resolvedName, op);
         if (resolved === null) {
-          return { resolvedName, foundCall: false };
+          return { resolvedName, foundCall: false, isGlobalCall };
+        }
+        if (isGlobalCall && this.analyzer.isScope(resolvedName)) {
+          isGlobalCall = false;
         }
         resolvedName = resolved;
         continue;
@@ -139605,11 +140451,11 @@ var FunctionCallListener = class extends CNextListener {
       if (op.argumentList() || op.getChildCount() === 2) {
         const text = op.getText();
         if (text.startsWith("(")) {
-          return { resolvedName, foundCall: true };
+          return { resolvedName, foundCall: true, isGlobalCall };
         }
       }
     }
-    return { resolvedName, foundCall: false };
+    return { resolvedName, foundCall: false, isGlobalCall };
   }
   /**
    * Resolve member access pattern. Returns new name or null if not a C-Next function.
@@ -139619,6 +140465,9 @@ var FunctionCallListener = class extends CNextListener {
     if (resolvedName === "this" && this.currentScope) {
       return `${this.currentScope}_${memberName}`;
     }
+    if (resolvedName === "global") {
+      return memberName;
+    }
     if (this.analyzer.isScope(resolvedName)) {
       return `${resolvedName}_${memberName}`;
     }
@@ -140017,8 +140866,9 @@ var FunctionCallAnalyzer = class {
    * @param line Source line number
    * @param column Source column number
    * @param currentScope The current scope name (if inside a scope)
+   * @param isGlobalCall Whether the call used global. prefix
    */
-  checkFunctionCall(name, line, column, currentScope) {
+  checkFunctionCall(name, line, column, currentScope, isGlobalCall = false) {
     if (this.currentFunctionName && name === this.currentFunctionName) {
       this.errors.push({
         code: "E0423",
@@ -140044,17 +140894,19 @@ var FunctionCallAnalyzer = class {
     if (this.callableVariables.has(name)) {
       return;
     }
-    if (currentScope) {
+    if (currentScope && !isGlobalCall) {
       const qualifiedName = `${currentScope}_${name}`;
       if (this.definedFunctions.has(qualifiedName)) {
         return;
       }
     }
+    const isLocalFunction = this.allLocalFunctions.has(name);
     const header = this.findStdlibHeader(name);
-    let message = `function '${name}' called before definition`;
-    if (header) {
-      message += `; hint: '${name}' is available from ${header} \u2014 try global.${name}()`;
-    }
+    const message = this.buildUndefinedFunctionMessage(
+      name,
+      header,
+      isGlobalCall && !isLocalFunction
+    );
     this.errors.push({
       code: "E0422",
       functionName: name,
@@ -140063,6 +140915,23 @@ var FunctionCallAnalyzer = class {
       message
     });
   }
+  /**
+   * Issue #985: Build error message for undefined function calls.
+   * Adjusts hint based on whether the call used global. prefix.
+   */
+  buildUndefinedFunctionMessage(name, header, isGlobalCall) {
+    if (isGlobalCall && header) {
+      return `'${name}' is not declared in any included header; add #include <${header}>`;
+    }
+    if (isGlobalCall) {
+      return `'${name}' is not declared in any included header`;
+    }
+    let message = `function '${name}' called before definition`;
+    if (header) {
+      message += `; hint: '${name}' is available from ${header} \u2014 try global.${name}()`;
+    }
+    return message;
+  }
   /**
    * Check if a function is defined externally (from included files)
    * This includes C/C++ headers AND C-Next includes.
@@ -140588,46 +141457,56 @@ var ArrayIndexTypeAnalyzer_default = ArrayIndexTypeAnalyzer;
 import { ParseTreeWalker as ParseTreeWalker9 } from "antlr4ng";
 var SignedVariableCollector = class extends CNextListener {
   signedVars = /* @__PURE__ */ new Set();
+  // Track all variable types (for resolving struct member chains)
+  varTypes = /* @__PURE__ */ new Map();
   getSignedVars() {
     return this.signedVars;
   }
+  getVarTypes() {
+    return this.varTypes;
+  }
   /**
-   * Track a typed identifier if it has a signed type
+   * Track a typed identifier - add to signedVars if signed, always track type
    */
-  trackIfSigned(typeCtx, identifier) {
-    if (!typeCtx) return;
+  trackType(typeCtx, identifier) {
+    if (!typeCtx || !identifier) return;
     const typeName = typeCtx.getText();
-    if (!TypeConstants_default.SIGNED_TYPES.includes(typeName)) return;
-    if (!identifier) return;
-    this.signedVars.add(identifier.getText());
+    const varName = identifier.getText();
+    this.varTypes.set(varName, typeName);
+    if (TypeConstants_default.SIGNED_TYPES.includes(typeName)) {
+      this.signedVars.add(varName);
+    }
   }
   /**
    * Track variable declarations with signed types
    */
   enterVariableDeclaration = (ctx) => {
-    this.trackIfSigned(ctx.type(), ctx.IDENTIFIER());
+    this.trackType(ctx.type(), ctx.IDENTIFIER());
   };
   /**
    * Track function parameters with signed types
    */
   enterParameter = (ctx) => {
-    this.trackIfSigned(ctx.type(), ctx.IDENTIFIER());
+    this.trackType(ctx.type(), ctx.IDENTIFIER());
   };
   /**
    * Track for-loop variable declarations with signed types
    */
   enterForVarDecl = (ctx) => {
-    this.trackIfSigned(ctx.type(), ctx.IDENTIFIER());
+    this.trackType(ctx.type(), ctx.IDENTIFIER());
   };
 };
 var SignedShiftListener = class extends CNextListener {
   analyzer;
   // eslint-disable-next-line @typescript-eslint/lines-between-class-members
   signedVars;
-  constructor(analyzer, signedVars) {
+  // eslint-disable-next-line @typescript-eslint/lines-between-class-members
+  varTypes;
+  constructor(analyzer, signedVars, varTypes) {
     super();
     this.analyzer = analyzer;
     this.signedVars = signedVars;
+    this.varTypes = varTypes;
   }
   /**
    * Check shift expressions for signed operands
@@ -140648,6 +141527,69 @@ var SignedShiftListener = class extends CNextListener {
       }
     }
   };
+  /**
+   * Check compound shift-assign statements for signed targets
+   * assignmentStatement: assignmentTarget assignmentOperator expression ';'
+   * Issue #1008: <<<- and >><- must also be rejected on signed types
+   *
+   * Handles both simple identifiers (x <<<- 2) and member chains (s.x <<<- 2)
+   */
+  enterAssignmentStatement = (ctx) => {
+    const opCtx = ctx.assignmentOperator();
+    if (!opCtx) return;
+    const isLeftShiftAssign = opCtx.LSHIFT_ASSIGN() !== null;
+    const isRightShiftAssign = opCtx.RSHIFT_ASSIGN() !== null;
+    if (!isLeftShiftAssign && !isRightShiftAssign) return;
+    const target = ctx.assignmentTarget();
+    if (!target) return;
+    const identifier = target.IDENTIFIER();
+    if (!identifier) return;
+    const baseName = identifier.getText();
+    const postfixOps = target.postfixTargetOp();
+    if (this.isSignedTarget(baseName, postfixOps)) {
+      const operator = isLeftShiftAssign ? "<<<-" : ">><-";
+      const { line, column } = ParserUtils_default.getPosition(target);
+      this.analyzer.addError(line, column, operator);
+    }
+  };
+  /**
+   * Resolve the final type of an assignment target, handling member chains.
+   * Returns true if the final target is a signed type.
+   *
+   * Examples:
+   *   - "x" with no postfix ops → check if x is signed
+   *   - "s" with postfixOps [".x"] → check if s.x field is signed
+   *   - "arr" with postfixOps ["[0]", ".field"] → check if field is signed
+   */
+  isSignedTarget(baseName, postfixOps) {
+    if (postfixOps.length === 0) {
+      return this.signedVars.has(baseName);
+    }
+    let currentType = this.varTypes.get(baseName);
+    if (!currentType) {
+      return false;
+    }
+    for (const op of postfixOps) {
+      const memberIdent = op.IDENTIFIER();
+      if (memberIdent) {
+        const fieldName = memberIdent.getText();
+        const fieldType = CodeGenState.getStructFieldType(
+          currentType,
+          fieldName
+        );
+        if (!fieldType) {
+          return false;
+        }
+        currentType = fieldType;
+      } else {
+        const bracketIndex = currentType.indexOf("[");
+        if (bracketIndex !== -1) {
+          currentType = currentType.substring(0, bracketIndex);
+        }
+      }
+    }
+    return TypeConstants_default.SIGNED_TYPES.includes(currentType);
+  }
   /**
    * Check if an additive expression contains a signed type operand
    */
@@ -140715,7 +141657,8 @@ var SignedShiftAnalyzer = class {
     const collector = new SignedVariableCollector();
     ParseTreeWalker9.DEFAULT.walk(collector, tree);
     const signedVars = collector.getSignedVars();
-    const listener = new SignedShiftListener(this, signedVars);
+    const varTypes = collector.getVarTypes();
+    const listener = new SignedShiftListener(this, signedVars, varTypes);
     ParseTreeWalker9.DEFAULT.walk(listener, tree);
     return this.errors;
   }
@@ -142423,7 +143366,12 @@ var Transpiler = class {
       this.state.getAllHeaderDirectives(),
       CodeGenState.symbolTable
     );
-    const typeInputWithSymbolTable = typeInput ? { ...typeInput, symbolTable: CodeGenState.symbolTable } : void 0;
+    const callbackTypesForHeader = this._buildCallbackTypesForHeader();
+    const typeInputWithSymbolTable = typeInput ? {
+      ...typeInput,
+      symbolTable: CodeGenState.symbolTable,
+      callbackTypes: callbackTypesForHeader
+    } : void 0;
     const unmodifiedParams = this.codeGenerator.getFunctionUnmodifiedParams();
     const headerSymbols = this.convertToHeaderSymbols(
       exportedSymbols,
@@ -142445,6 +143393,32 @@ var Transpiler = class {
       basename6(sourcePath)
     );
   }
+  /**
+   * ADR-029: Build callback types for header generation.
+   * Only includes callbacks that are actually used as struct field types.
+   * Converts CodeGenState.callbackTypes to the format expected by IHeaderTypeInput.
+   */
+  _buildCallbackTypesForHeader() {
+    const result = /* @__PURE__ */ new Map();
+    const usedCallbackTypes = /* @__PURE__ */ new Set();
+    for (const [, funcName] of CodeGenState.callbackFieldTypes) {
+      usedCallbackTypes.add(funcName);
+    }
+    for (const funcName of usedCallbackTypes) {
+      const cbInfo = CodeGenState.callbackTypes.get(funcName);
+      if (cbInfo) {
+        result.set(funcName, {
+          typedefName: cbInfo.typedefName,
+          returnType: cbInfo.returnType,
+          parameters: cbInfo.parameters.map((p) => ({
+            type: p.type,
+            isStruct: p.isStruct
+          }))
+        });
+      }
+    }
+    return result;
+  }
   /**
    * Collect external enum sources from included C-Next files.
    */
@@ -142491,25 +143465,27 @@ var Transpiler = class {
       );
       const callbackTypedefType = typedefName ? CodeGenState.getTypedefType(typedefName) : void 0;
       if (callbackTypedefType) {
-        const updatedParams = TypedefParamParser_default.resolveCallbackParams(
+        const updatedParams2 = TypedefParamParser_default.resolveCallbackParams(
           headerSymbol.parameters,
           callbackTypedefType
         );
-        return { ...headerSymbol, parameters: updatedParams };
+        return { ...headerSymbol, parameters: updatedParams2 };
       }
       const unmodified = unmodifiedParams.get(headerSymbol.name);
-      if (unmodified) {
-        const updatedParams = headerSymbol.parameters.map((param) => {
-          const isPointerParam = !param.isConst && !param.isArray && param.type !== "f32" && param.type !== "f64" && param.type !== "ISR" && !knownEnums.has(param.type ?? "");
-          const isArrayParam = param.isArray && !param.isConst;
-          if ((isPointerParam || isArrayParam) && unmodified.has(param.name)) {
-            return { ...param, isAutoConst: true };
-          }
-          return param;
-        });
-        return { ...headerSymbol, parameters: updatedParams };
-      }
-      return headerSymbol;
+      const updatedParams = headerSymbol.parameters.map((param) => {
+        const isOpaque = CodeGenState.isOpaqueType(param.type ?? "");
+        const isPointerParam = !param.isConst && !param.isArray && param.type !== "f32" && param.type !== "f64" && param.type !== "ISR" && !knownEnums.has(param.type ?? "");
+        const shouldAutoConst = unmodified && isPointerParam && unmodified.has(param.name);
+        if (shouldAutoConst || isOpaque) {
+          return {
+            ...param,
+            isAutoConst: shouldAutoConst || void 0,
+            isOpaqueHandle: isOpaque || void 0
+          };
+        }
+        return param;
+      });
+      return { ...headerSymbol, parameters: updatedParams };
     });
   }
   // ===========================================================================