c-next 0.2.11 → 0.2.13

package/src/transpiler/logic/symbols/cnext/__tests__/TSymbolInfoAdapter.test.ts

@@ -466,7 +466,7 @@ describe("TSymbolInfoAdapter", () => {
       const motorScope = TestScopeUtils.createMockScope("Motor");
       const variable: IVariableSymbol = {
         kind: "variable",
-        name: "MAX_SPEED", // Bare name - adapter computes mangled name
+        name: "MAX_SPEED", // Bare name - adapter computes transpiled C name
         scope: motorScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
@@ -481,7 +481,7 @@ describe("TSymbolInfoAdapter", () => {
 
       const info = TSymbolInfoAdapter.convert([variable]);
 
-      // Adapter stores using mangled name (scope + bare name)
+      // Adapter stores using transpiled C name (scope + bare name)
       expect(info.scopePrivateConstValues.get("Motor_MAX_SPEED")).toBe("255");
     });
 
@@ -489,7 +489,7 @@ describe("TSymbolInfoAdapter", () => {
       const motorScope = TestScopeUtils.createMockScope("Motor");
       const variable: IVariableSymbol = {
         kind: "variable",
-        name: "PUBLIC_CONST", // Bare name - adapter computes mangled name
+        name: "PUBLIC_CONST", // Bare name - adapter computes transpiled C name
         scope: motorScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
@@ -513,7 +513,7 @@ describe("TSymbolInfoAdapter", () => {
       const motorScope = TestScopeUtils.createMockScope("Motor");
       const variable: IVariableSymbol = {
         kind: "variable",
-        name: "counter", // Bare name - adapter computes mangled name
+        name: "counter", // Bare name - adapter computes transpiled C name
         scope: motorScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
@@ -535,7 +535,7 @@ describe("TSymbolInfoAdapter", () => {
       const motorScope = TestScopeUtils.createMockScope("Motor");
       const variable: IVariableSymbol = {
         kind: "variable",
-        name: "LOOKUP_TABLE", // Bare name - adapter computes mangled name
+        name: "LOOKUP_TABLE", // Bare name - adapter computes transpiled C name
         scope: motorScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
@@ -562,7 +562,7 @@ describe("TSymbolInfoAdapter", () => {
       const motorScope = TestScopeUtils.createMockScope("Motor");
       const variable: IVariableSymbol = {
         kind: "variable",
-        name: "MATRIX", // Bare name - adapter computes mangled name
+        name: "MATRIX", // Bare name - adapter computes transpiled C name
         scope: motorScope,
         sourceFile: "test.cnx",
         sourceLine: 1,

package/src/transpiler/logic/symbols/cnext/adapters/TSymbolInfoAdapter.ts

@@ -239,8 +239,9 @@ class TSymbolInfoAdapter {
 
   // === Private Processing Methods ===
 
-  // Use shared utility for name mangling
-  private static readonly getMangledName = SymbolNameUtils.getMangledName;
+  // Use shared utility for transpiled C names
+  private static readonly getTranspiledCName =
+    SymbolNameUtils.getTranspiledCName;
 
   private static processStruct(
     struct: IStructSymbol,
@@ -249,9 +250,9 @@ class TSymbolInfoAdapter {
     structFieldArrays: Map<string, Set<string>>,
     structFieldDimensions: Map<string, Map<string, number[]>>,
   ): void {
-    // Use mangled name for lookups (e.g., "Geometry_Point")
-    const mangledName = TSymbolInfoAdapter.getMangledName(struct);
-    knownStructs.add(mangledName);
+    // Use transpiled C name for lookups (e.g., "Geometry_Point")
+    const cName = TSymbolInfoAdapter.getTranspiledCName(struct);
+    knownStructs.add(cName);
 
     const fields = new Map<string, string>();
     const arrayFields = new Set<string>();
@@ -277,10 +278,10 @@ class TSymbolInfoAdapter {
       }
     }
 
-    structFields.set(mangledName, fields);
-    structFieldArrays.set(mangledName, arrayFields);
+    structFields.set(cName, fields);
+    structFieldArrays.set(cName, arrayFields);
     if (dimensions.size > 0) {
-      structFieldDimensions.set(mangledName, dimensions);
+      structFieldDimensions.set(cName, dimensions);
     }
   }
 
@@ -289,9 +290,9 @@ class TSymbolInfoAdapter {
     knownEnums: Set<string>,
     enumMembers: Map<string, Map<string, number>>,
   ): void {
-    const mangledName = TSymbolInfoAdapter.getMangledName(enumSym);
-    knownEnums.add(mangledName);
-    enumMembers.set(mangledName, new Map(enumSym.members));
+    const cName = TSymbolInfoAdapter.getTranspiledCName(enumSym);
+    knownEnums.add(cName);
+    enumMembers.set(cName, new Map(enumSym.members));
   }
 
   private static processBitmap(
@@ -301,10 +302,10 @@ class TSymbolInfoAdapter {
     bitmapBackingType: Map<string, string>,
     bitmapBitWidth: Map<string, number>,
   ): void {
-    const mangledName = TSymbolInfoAdapter.getMangledName(bitmap);
-    knownBitmaps.add(mangledName);
-    bitmapBackingType.set(mangledName, bitmap.backingType);
-    bitmapBitWidth.set(mangledName, bitmap.bitWidth);
+    const cName = TSymbolInfoAdapter.getTranspiledCName(bitmap);
+    knownBitmaps.add(cName);
+    bitmapBackingType.set(cName, bitmap.backingType);
+    bitmapBitWidth.set(cName, bitmap.bitWidth);
 
     const fields = new Map<string, { offset: number; width: number }>();
     for (const [fieldName, fieldInfo] of bitmap.fields) {
@@ -313,7 +314,7 @@ class TSymbolInfoAdapter {
         width: fieldInfo.width,
       });
     }
-    bitmapFields.set(mangledName, fields);
+    bitmapFields.set(cName, fields);
   }
 
   private static processScope(
@@ -338,18 +339,18 @@ class TSymbolInfoAdapter {
     knownBitmaps: Set<string>,
     maps: IRegisterMaps,
   ): void {
-    const mangledName = TSymbolInfoAdapter.getMangledName(register);
-    maps.knownRegisters.add(mangledName);
-    maps.registerBaseAddresses.set(mangledName, register.baseAddress);
+    const cName = TSymbolInfoAdapter.getTranspiledCName(register);
+    maps.knownRegisters.add(cName);
+    maps.registerBaseAddresses.set(cName, register.baseAddress);
 
     // Check if this is a scoped register (has non-global scope)
     const isScoped = register.scope.name !== "";
     if (isScoped) {
-      maps.scopedRegisters.set(mangledName, register.baseAddress);
+      maps.scopedRegisters.set(cName, register.baseAddress);
     }
 
     for (const [memberName, memberInfo] of register.members) {
-      const fullName = `${mangledName}_${memberName}`;
+      const fullName = `${cName}_${memberName}`;
 
       maps.registerMemberAccess.set(fullName, memberInfo.access);
       maps.registerMemberOffsets.set(fullName, memberInfo.offset);
@@ -370,7 +371,7 @@ class TSymbolInfoAdapter {
     scopeMembers: Map<string, Set<string>>,
     scopePrivateConstValues: Map<string, string>,
   ): void {
-    const mangledName = TSymbolInfoAdapter.getMangledName(variable);
+    const cName = TSymbolInfoAdapter.getTranspiledCName(variable);
     const scopeName = variable.scope.name;
     const isScoped = scopeName !== "";
 
@@ -381,7 +382,7 @@ class TSymbolInfoAdapter {
         members = new Set<string>();
         scopeMembers.set(scopeName, members);
       }
-      members.add(variable.name); // Add local name (e.g., "value"), not mangled
+      members.add(variable.name); // Add local name (e.g., "value"), not transpiled C name
     }
 
     // Issue #282: Track private const values for inlining
@@ -395,7 +396,7 @@ class TSymbolInfoAdapter {
       variable.initialValue &&
       !variable.isArray
     ) {
-      scopePrivateConstValues.set(mangledName, variable.initialValue);
+      scopePrivateConstValues.set(cName, variable.initialValue);
     }
   }
 
@@ -405,10 +406,10 @@ class TSymbolInfoAdapter {
   ): void {
     // Track function return types for enum validation in assignments
     // This enables recognizing that Motor.getMode() returns Motor_EMode
-    // Use mangled name (e.g., "Motor_getMode") for lookup consistency
-    const mangledName = TSymbolInfoAdapter.getMangledName(func);
+    // Use transpiled C name (e.g., "Motor_getMode") for lookup consistency
+    const cName = TSymbolInfoAdapter.getTranspiledCName(func);
     const returnTypeStr = TypeResolver.getTypeName(func.returnType);
-    functionReturnTypes.set(mangledName, returnTypeStr);
+    functionReturnTypes.set(cName, returnTypeStr);
   }
 
   private static cnextTypeToCType(typeName: string): string {

package/src/transpiler/logic/symbols/cnext/index.ts

@@ -164,7 +164,7 @@ class CNextResolver {
           globalScope,
         );
         symbols.push(symbol);
-        // Use mangled name (global bitmaps have no scope prefix)
+        // Use transpiled C name (global bitmaps have no scope prefix)
         knownBitmaps.add(symbol.name);
       }
 
@@ -200,9 +200,9 @@ class CNextResolver {
         const bitmapCtx = member.bitmapDeclaration()!;
         const symbol = BitmapCollector.collect(bitmapCtx, sourceFile, scope);
         symbols.push(symbol);
-        // Use mangled name (e.g., "Timer_ControlBits") for scoped bitmaps
-        const mangledName = `${scopeName}_${symbol.name}`;
-        knownBitmaps.add(mangledName);
+        // Use transpiled C name (e.g., "Timer_ControlBits") for scoped bitmaps
+        const cName = `${scopeName}_${symbol.name}`;
+        knownBitmaps.add(cName);
       }
 
       // Collect structs early so they're available as types

package/src/transpiler/logic/symbols/cnext/utils/SymbolNameUtils.ts

@@ -3,13 +3,13 @@
  */
 
 /**
- * Get the C-mangled name for a symbol (e.g., "Geometry_Point" for Point in Geometry scope).
- * Works with any symbol that has a name and scope reference.
+ * Get the transpiled C name for a symbol (e.g., "Geometry_Point" for Point in Geometry scope).
+ * Use only at the output layer for C code generation, not for input-side logic.
  *
  * @param symbol Object with name and scope.name properties
- * @returns The mangled name (e.g., "Motor_init") or bare name if global scope
+ * @returns The C output name (e.g., "Motor_init") or bare name if global scope
  */
-function getMangledName(symbol: {
+function getTranspiledCName(symbol: {
   name: string;
   scope: { name: string };
 }): string {
@@ -21,7 +21,7 @@ function getMangledName(symbol: {
 }
 
 class SymbolNameUtils {
-  static readonly getMangledName = getMangledName;
+  static readonly getTranspiledCName = getTranspiledCName;
 }
 
 export default SymbolNameUtils;

package/src/transpiler/output/codegen/CodeGenerator.ts

@@ -3,6 +3,7 @@
  * Transforms C-Next AST to clean, readable C code
  */
 
+import { basename } from "node:path";
 import { CommonTokenStream, ParserRuleContext } from "antlr4ng";
 import * as Parser from "../../logic/parser/grammar/CNextParser";
 
@@ -2225,9 +2226,14 @@ export default class CodeGenerator implements IOrchestrator {
     const output: string[] = [];
     const symbols = CodeGenState.symbols!;
     // Add header comment
+    const sourcePath = CodeGenState.sourcePath;
+    const generatedLine = sourcePath
+      ? ` * Generated by C-Next Transpiler from: ${basename(sourcePath)}`
+      : " * Generated by C-Next Transpiler";
+
     output.push(
       "/**",
-      " * Generated by C-Next Transpiler",
+      generatedLine,
       " * A safer C for embedded systems",
       " */",
       "",
@@ -3675,6 +3681,8 @@ export default class CodeGenerator implements IOrchestrator {
       isStructType: (typeName: string) => this.isStructType(typeName),
       resolveQualifiedType: (identifiers: string[]) =>
         this.resolveQualifiedType(identifiers),
+      isTypedefStructType: (t: string) =>
+        CodeGenState.symbolTable?.isTypedefStructType(t) ?? false,
     };
   }
 
@@ -3766,6 +3774,8 @@ export default class CodeGenerator implements IOrchestrator {
       isCallbackCompatible,
       forcePassByReference,
       forceConst,
+      isTypedefStructType: (t) =>
+        CodeGenState.symbolTable?.isTypedefStructType(t) ?? false,
     });
 
     // Use shared builder with C/C++ mode
@@ -3892,6 +3902,11 @@ export default class CodeGenerator implements IOrchestrator {
   ): string {
     const type = this.generateType(ctx.type());
 
+    // Issue #958: C-header typedef struct types always need pointer semantics
+    if (CodeGenState.symbolTable?.isTypedefStructType(type)) {
+      return `${type}*`;
+    }
+
     if (!ctx.expression()) {
       return type;
     }

package/src/transpiler/output/codegen/__tests__/CodeGenerator.test.ts

@@ -164,6 +164,21 @@ describe("CodeGenerator", () => {
 
       expect(code).toContain("void foo");
     });
+
+    it("should include source path in generation comment", () => {
+      const source = `void test() { }`;
+      const { tree, tokenStream } = CNextSourceParser.parse(source);
+      const generator = new CodeGenerator();
+      const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+      const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+      const code = generator.generate(tree, tokenStream, {
+        symbolInfo: symbols,
+        sourcePath: "led.cnx",
+      });
+
+      expect(code).toContain("Generated by C-Next Transpiler from: led.cnx");
+    });
   });
 
   describe("IOrchestrator interface", () => {

package/src/transpiler/output/codegen/__tests__/ExpressionWalker.test.ts

@@ -311,7 +311,7 @@ describe("ExpressionWalker - const inference integration", () => {
         caller(val);
       }
     `;
-    const transpiler = new Transpiler({ inputs: [] });
+    const transpiler = new Transpiler({ input: "" });
     const transpileResult = (
       await transpiler.transpile({ kind: "source", source: source })
     ).files[0];
@@ -341,7 +341,7 @@ describe("ExpressionWalker - const inference integration", () => {
         caller(val);
       }
     `;
-    const transpiler = new Transpiler({ inputs: [] });
+    const transpiler = new Transpiler({ input: "" });
     const transpileResult = (
       await transpiler.transpile({ kind: "source", source: source })
     ).files[0];
@@ -370,7 +370,7 @@ describe("ExpressionWalker - const inference integration", () => {
         caller(val);
       }
     `;
-    const transpiler = new Transpiler({ inputs: [] });
+    const transpiler = new Transpiler({ input: "" });
     const transpileResult = (
       await transpiler.transpile({ kind: "source", source: source })
     ).files[0];

package/src/transpiler/output/codegen/__tests__/RequireInclude.test.ts

@@ -18,7 +18,7 @@ describe("CodeGenerator requireInclude", () => {
 
   describe("stdint includes", () => {
     it("includes stdint.h for u8 type", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({ kind: "source", source: "u8 value <- 0;" })
@@ -29,7 +29,7 @@ describe("CodeGenerator requireInclude", () => {
     });
 
     it("includes stdint.h for u16 type", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({
@@ -43,7 +43,7 @@ describe("CodeGenerator requireInclude", () => {
     });
 
     it("includes stdint.h for u32 type", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({
@@ -57,7 +57,7 @@ describe("CodeGenerator requireInclude", () => {
     });
 
     it("includes stdint.h for i32 type", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({
@@ -71,7 +71,7 @@ describe("CodeGenerator requireInclude", () => {
     });
 
     it("includes stdint.h for bitmap types", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({
@@ -94,7 +94,7 @@ describe("CodeGenerator requireInclude", () => {
 
   describe("stdbool includes", () => {
     it("includes stdbool.h for bool type", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({
@@ -110,7 +110,7 @@ describe("CodeGenerator requireInclude", () => {
 
   describe("string includes", () => {
     it("includes string.h for bounded string type", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({
@@ -124,7 +124,7 @@ describe("CodeGenerator requireInclude", () => {
     });
 
     it("includes string.h for const string inference", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({
@@ -140,7 +140,7 @@ describe("CodeGenerator requireInclude", () => {
 
   describe("isr includes", () => {
     it("generates ISR typedef for ISR type", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({
@@ -156,7 +156,7 @@ describe("CodeGenerator requireInclude", () => {
 
   describe("float static assert includes", () => {
     it("generates static assert for float bit indexing write", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({
@@ -177,7 +177,7 @@ describe("CodeGenerator requireInclude", () => {
     });
 
     it("generates static assert for float bit indexing read (no string.h)", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({
@@ -201,7 +201,7 @@ describe("CodeGenerator requireInclude", () => {
 
   describe("limits includes", () => {
     it("includes limits.h for float-to-int clamp cast", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({
@@ -221,7 +221,7 @@ describe("CodeGenerator requireInclude", () => {
 
   describe("multiple includes", () => {
     it("includes multiple headers when needed", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({
@@ -241,7 +241,7 @@ describe("CodeGenerator requireInclude", () => {
     });
 
     it("does not include unused headers", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({

package/src/transpiler/output/codegen/__tests__/TrackVariableTypeHelpers.test.ts

@@ -11,7 +11,7 @@ import Transpiler from "../../../Transpiler";
  * Helper to transpile C-Next source and return the C output
  */
 async function transpileSource(source: string): Promise<string> {
-  const transpiler = new Transpiler({ inputs: [] });
+  const transpiler = new Transpiler({ input: "" });
   const result = (
     await transpiler.transpile({ kind: "source", source: source })
   ).files[0];
@@ -130,7 +130,7 @@ describe("trackVariableTypeWithName helpers", () => {
         }
       `;
       const code = await transpileSource(source);
-      // Scoped type should be mangled to Motor_State
+      // Scoped type should be transpiled to Motor_State
       expect(code).toContain("Motor_State");
     });
 

package/src/transpiler/output/codegen/helpers/FunctionContextManager.ts

@@ -160,19 +160,27 @@ class FunctionContextManager {
     const isCallbackPointerParam =
       callbackTypedefInfo?.shouldBePointer ?? false;
 
+    // Issue #958: Check if type is a typedef'd struct from C headers
+    const isTypedefStruct =
+      callbacks.isTypedefStructType?.(typeInfo.typeName) ?? false;
+
     // Determine isStruct: for callback-compatible params, both typedef AND type info matter
     // - If typedef says pointer AND it's actually a struct, use -> access (isStruct=true)
     // - If typedef says pointer BUT it's a primitive (like u8), don't treat as struct
     //   (primitives use forcePointerSemantics for dereference instead)
+    // Issue #958: C-header typedef struct types are always treated as struct (pointer semantics)
     const isStruct = callbackTypedefInfo
       ? isCallbackPointerParam && typeInfo.isStruct
-      : typeInfo.isStruct;
+      : typeInfo.isStruct || isTypedefStruct;
 
     // Issue #895: Primitive types that become pointers need dereferencing when used as values
     // e.g., "u8 buf" becoming "uint8_t* buf" requires "*buf" when accessing the value
     const isCallbackPointerPrimitive =
       isCallbackPointerParam && !typeInfo.isStruct && !isArray;
 
+    // Issue #958: typedef struct params need pointer semantics (like callback pointer params)
+    const forcePointerSemantics = isCallbackPointerParam || isTypedefStruct;
+
     // Register in currentParameters
     const paramInfo = {
       name,
@@ -183,8 +191,8 @@ class FunctionContextManager {
       isCallback: typeInfo.isCallback,
       isString: typeInfo.isString,
       isCallbackPointerPrimitive,
-      // Issue #895: Callback-compatible params need pointer semantics even in C++ mode
-      forcePointerSemantics: isCallbackPointerParam,
+      // Issue #895/#958: Force pointer semantics for callback-compatible and typedef struct params
+      forcePointerSemantics,
     };
     CodeGenState.currentParameters.set(name, paramInfo);
 
@@ -195,6 +203,7 @@ class FunctionContextManager {
       param,
       isArray,
       isConst,
+      isTypedefStruct,
     );
   }
 
@@ -320,6 +329,7 @@ class FunctionContextManager {
     param: Parser.ParameterContext,
     isArray: boolean,
     isConst: boolean,
+    isTypedefStruct = false,
   ): void {
     const { typeName, isString } = typeInfo;
     const typeCtx = param.type();
@@ -358,6 +368,8 @@ class FunctionContextManager {
       isString,
       stringCapacity,
       isParameter: true,
+      // Issue #958: typedef struct params are already pointers — prevent &arg in call sites
+      ...(isTypedefStruct && { isPointer: true }),
     };
     CodeGenState.setVariableTypeInfo(name, registeredType);
   }

package/src/transpiler/output/codegen/helpers/ParameterInputAdapter.ts

@@ -52,6 +52,9 @@ interface IFromASTDeps {
    */
   forcePassByReference?: boolean;
 
+  /** Issue #958: Check if a type name is a typedef'd struct from C headers */
+  isTypedefStructType: (typeName: string) => boolean;
+
   /**
    * Issue #895: Force const qualifier from callback typedef signature.
    * When the C typedef has `const T*`, this preserves const on the generated param.
@@ -137,15 +140,19 @@ class ParameterInputAdapter {
     // Determine classification for non-array, non-string types
     const isKnownStruct = deps.isKnownStruct(typeName);
     const isKnownPrimitive = !!deps.typeMap[typeName];
+    // Issue #958: C-header typedef struct types need pointer semantics
+    const isTypedefStruct = deps.isTypedefStructType(typeName);
     // Issue #895: Don't add auto-const for callback-compatible functions
     // because it would change the signature and break typedef compatibility
     const isAutoConst =
       !deps.isCallbackCompatible && !deps.isModified && !isConst;
 
-    // Issue #895: For callback-compatible functions, force pass-by-reference
-    // when the typedef signature requires a pointer (e.g., opaque types)
+    // Issue #895/#958: Force pass-by-reference for callback or typedef struct types
     const isPassByReference =
-      deps.forcePassByReference || isKnownStruct || isKnownPrimitive;
+      deps.forcePassByReference ||
+      isKnownStruct ||
+      isKnownPrimitive ||
+      isTypedefStruct;
 
     return {
       name,
@@ -158,9 +165,10 @@ class ParameterInputAdapter {
       isString: false,
       isPassByValue: deps.isPassByValue,
       isPassByReference,
-      // Issue #895: Force pointer syntax in C++ mode for callback-compatible functions
-      // because C callback typedefs expect pointers, not C++ references
-      forcePointerSyntax: deps.forcePassByReference,
+      // Issue #895/#958: Force pointer syntax in C++ mode for callback-compatible
+      // and typedef struct params (C types expect pointers, not C++ references)
+      forcePointerSyntax:
+        deps.forcePassByReference || isTypedefStruct || undefined,
       // Issue #895: Preserve const from callback typedef signature
       forceConst: deps.forceConst,
     };

package/src/transpiler/output/codegen/helpers/__tests__/ParameterInputAdapter.test.ts

@@ -62,6 +62,7 @@ function createDefaultASTDeps(overrides?: {
     isModified: overrides?.isModified ?? false,
     isPassByValue: overrides?.isPassByValue ?? false,
     isCallbackCompatible: false,
+    isTypedefStructType: () => false,
   };
 }
 

package/src/transpiler/output/codegen/types/IFunctionContextCallbacks.ts

@@ -7,6 +7,8 @@ interface IFunctionContextCallbacks {
   isStructType: (typeName: string) => boolean;
   /** Resolve qualified type identifiers to a type name */
   resolveQualifiedType: (identifiers: string[]) => string;
+  /** Issue #958: Check if a type name is a typedef'd struct from C headers */
+  isTypedefStructType?: (typeName: string) => boolean;
 }
 
 export default IFunctionContextCallbacks;

package/src/transpiler/output/codegen/utils/QualifiedNameGenerator.ts

@@ -1,8 +1,8 @@
 /**
  * QualifiedNameGenerator - C-style name generation for C-Next symbols
  *
- * Provides C-style mangled name generation for use in the output layer.
- * Delegates to FunctionUtils.getCMangledName() for the actual implementation
+ * Provides transpiled C name generation for use in the output layer.
+ * Delegates to FunctionUtils.getTranspiledCName() for the actual implementation
  * to avoid duplication with the types layer.
  *
  * Design decisions:
@@ -24,16 +24,16 @@ class QualifiedNameGenerator {
   // ============================================================================
 
   /**
-   * Generate the C-style mangled name for a function.
+   * Generate the transpiled C name for a function.
    *
    * For global scope functions, returns the bare name (e.g., "main").
    * For scoped functions, returns "Scope_name" (e.g., "Test_fillData").
    * For nested scopes, returns "Outer_Inner_name" (e.g., "Outer_Inner_deepFunc").
    *
-   * Delegates to FunctionUtils.getCMangledName() to avoid duplication.
+   * Delegates to FunctionUtils.getTranspiledCName() to avoid duplication.
    */
   static forFunction(func: IFunctionSymbol): string {
-    return FunctionUtils.getCMangledName(func);
+    return FunctionUtils.getTranspiledCName(func);
   }
 
   /**
@@ -61,7 +61,7 @@ class QualifiedNameGenerator {
    *
    * @param scopeName Scope name (e.g., "Test", "Outer.Inner") or undefined for global
    * @param funcName Bare function name (e.g., "fillData")
-   * @returns C-mangled name (e.g., "Test_fillData")
+   * @returns Transpiled C name (e.g., "Test_fillData")
    */
   static forFunctionStrings(
     scopeName: string | undefined,
@@ -100,7 +100,7 @@ class QualifiedNameGenerator {
    *
    * @param scopeName Scope name or undefined for global
    * @param memberName Member name
-   * @returns C-mangled name
+   * @returns Transpiled C name
    */
   static forMember(scopeName: string | undefined, memberName: string): string {
     if (!scopeName) {