c-next 0.2.4 → 0.2.5

package/dist/index.js

@@ -10,7 +10,7 @@ import { hideBin } from "yargs/helpers";
 // package.json
 var package_default = {
   name: "c-next",
-  version: "0.2.4",
+  version: "0.2.5",
   description: "A safer C for embedded systems development. Transpiles to clean, readable C.",
   packageManager: "npm@11.9.0",
   type: "module",
@@ -32,6 +32,8 @@ var package_default = {
     "test:cli": "node scripts/test-cli.js",
     "test:q": "tsx scripts/test.ts -q",
     "test:update": "tsx scripts/test.ts --update",
+    "integration:transpile": "tsx scripts/test.ts --transpile-only",
+    "integration:execute": "tsx scripts/test.ts --execute-only",
     analyze: "./scripts/static-analysis.sh",
     clean: "rm -rf dist src/transpiler/logic/parser/grammar src/transpiler/logic/parser/c/grammar src/transpiler/logic/parser/cpp/grammar",
     "prettier:check": "prettier --check .",
@@ -110764,8 +110766,12 @@ var CodeGenState = class {
   static callbackTypes = /* @__PURE__ */ new Map();
   /** Callback field types: "Struct.field" -> callbackTypeName */
   static callbackFieldTypes = /* @__PURE__ */ new Map();
-  /** Functions that need C-callback-compatible (by-value) struct parameters */
-  static callbackCompatibleFunctions = /* @__PURE__ */ new Set();
+  /**
+   * Functions that are assigned to C callback typedefs.
+   * Maps function name -> typedef name (e.g., "my_flush" -> "flush_cb_t")
+   * Issue #895: We need the typedef name to look up parameter types.
+   */
+  static callbackCompatibleFunctions = /* @__PURE__ */ new Map();
   // ===========================================================================
   // PASS-BY-VALUE ANALYSIS (Issue #269)
   // ===========================================================================
@@ -111133,6 +111139,20 @@ var CodeGenState = class {
   static getCallbackType(name) {
     return this.callbackTypes.get(name);
   }
+  /**
+   * Issue #895: Get the typedef type string for a C typedef by name.
+   * Used to look up function pointer typedef signatures for callback-compatible functions.
+   *
+   * @param typedefName - Name of the typedef (e.g., "flush_cb_t")
+   * @returns The type string (e.g., "void (*)(widget_t *, const rect_t *, uint8_t *)") or undefined
+   */
+  static getTypedefType(typedefName) {
+    const symbol = this.symbolTable.getCSymbol(typedefName);
+    if (symbol?.kind === "type") {
+      return symbol.type;
+    }
+    return void 0;
+  }
   /**
    * Check if a type name is a known C-Next function.
    */
@@ -112906,7 +112926,7 @@ var TYPE_RANGES = {
 };
 var TYPE_RANGES_default = TYPE_RANGES;
 
-// src/transpiler/output/codegen/utils/ExpressionUnwrapper.ts
+// src/utils/ExpressionUnwrapper.ts
 var ExpressionUnwrapper = class {
   /**
    * Navigate from ExpressionContext to ShiftExpressionContext.
@@ -115744,6 +115764,7 @@ var generatePostfixExpression = (ctx, input, state, orchestrator) => {
   const rootIdentifier = primary.IDENTIFIER()?.getText();
   const paramInfo = rootIdentifier ? state.currentParameters.get(rootIdentifier) : null;
   const isStructParam = paramInfo?.isStruct ?? false;
+  const forcePointerSemantics = paramInfo?.forcePointerSemantics ?? false;
   const hasSubscriptOps = ops.some((op) => op.expression().length > 0);
   const isNonArrayParamWithSubscript = paramInfo && !paramInfo.isArray && !paramInfo.isStruct && hasSubscriptOps;
   let result;
@@ -115764,6 +115785,7 @@ var generatePostfixExpression = (ctx, input, state, orchestrator) => {
   const postfixCtx = {
     rootIdentifier,
     isStructParam,
+    forcePointerSemantics,
     input,
     state,
     orchestrator,
@@ -115855,6 +115877,7 @@ var handleMemberOp = (memberName, tracking, ctx) => {
       memberName,
       rootIdentifier: ctx.rootIdentifier,
       isStructParam: ctx.isStructParam,
+      forcePointerSemantics: ctx.forcePointerSemantics,
       isGlobalAccess: tracking.isGlobalAccess,
       isCppAccessChain: tracking.isCppAccessChain,
       currentStructType: tracking.currentStructType,
@@ -116589,7 +116612,7 @@ var tryStructParamAccess = (ctx, orchestrator) => {
   if (!ctx.isStructParam || ctx.result !== ctx.rootIdentifier) {
     return null;
   }
-  const structParamSep = memberAccessChain_default.getStructParamSeparator({
+  const structParamSep = ctx.forcePointerSemantics ? "->" : memberAccessChain_default.getStructParamSeparator({
     cppMode: orchestrator.isCppMode()
   });
   const output = initializeMemberOutput(ctx);
@@ -124794,7 +124817,16 @@ var MemberSeparatorResolver = class _MemberSeparatorResolver {
   /**
    * Build the separator context for a member access chain
    */
-  static buildContext(firstId, hasGlobal, hasThis, currentScope, isStructParam, deps, isCppAccess) {
+  static buildContext(input, deps) {
+    const {
+      firstId,
+      hasGlobal,
+      hasThis,
+      currentScope,
+      isStructParam,
+      isCppAccess,
+      forcePointerSemantics
+    } = input;
     const isCrossScope = hasGlobal && (deps.isKnownScope(firstId) || deps.isKnownRegister(firstId));
     const scopedRegName = hasThis && currentScope ? `${currentScope}_${firstId}` : null;
     const isScopedRegister = scopedRegName !== null && deps.isKnownRegister(scopedRegName);
@@ -124804,7 +124836,8 @@ var MemberSeparatorResolver = class _MemberSeparatorResolver {
       isStructParam,
       isCppAccess,
       scopedRegName,
-      isScopedRegister
+      isScopedRegister,
+      forcePointerSemantics
     };
   }
   /**
@@ -124815,6 +124848,9 @@ var MemberSeparatorResolver = class _MemberSeparatorResolver {
       return "::";
     }
     if (ctx.isStructParam) {
+      if (ctx.forcePointerSemantics) {
+        return "->";
+      }
       return deps.getStructParamSeparator();
     }
     if (ctx.isCrossScope) {
@@ -124875,6 +124911,9 @@ var ParameterDereferenceResolver = class _ParameterDereferenceResolver {
    * Determine if a parameter should be passed by value (no dereference needed)
    */
   static isPassByValue(paramInfo, deps) {
+    if (paramInfo.isCallbackPointerPrimitive) {
+      return false;
+    }
     if (paramInfo.isCallback) {
       return true;
     }
@@ -124913,6 +124952,9 @@ var ParameterDereferenceResolver = class _ParameterDereferenceResolver {
     if (_ParameterDereferenceResolver.isPassByValue(paramInfo, deps)) {
       return id;
     }
+    if (paramInfo.forcePointerSemantics) {
+      return `(*${id})`;
+    }
     return deps.maybeDereference(id);
   }
 };
@@ -125455,6 +125497,137 @@ var CastValidator = class _CastValidator {
 };
 var CastValidator_default = CastValidator;
 
+// src/transpiler/output/codegen/helpers/TypedefParamParser.ts
+var TypedefParamParser = class _TypedefParamParser {
+  /**
+   * Parse a function pointer typedef type string.
+   *
+   * @param typedefType - The type string, e.g., "void (*)(widget_t *, const rect_t *, uint8_t *)"
+   * @returns Parsed result with return type and parameters, or null if parsing fails
+   */
+  static parse(typedefType) {
+    const funcPtrIndex = typedefType.indexOf("(*)");
+    if (funcPtrIndex === -1) {
+      return null;
+    }
+    const returnType = typedefType.substring(0, funcPtrIndex).trim();
+    const afterFuncPtr = typedefType.substring(funcPtrIndex + 3).trim();
+    if (!afterFuncPtr.startsWith("(")) {
+      return null;
+    }
+    const paramsStr = _TypedefParamParser.extractParenContent(afterFuncPtr);
+    if (paramsStr === null) {
+      return null;
+    }
+    if (!paramsStr || paramsStr === "void") {
+      return { returnType, params: [] };
+    }
+    const paramStrings = _TypedefParamParser.splitParams(paramsStr);
+    const params = paramStrings.map((p) => _TypedefParamParser.parseParam(p));
+    return { returnType, params };
+  }
+  /**
+   * Extract content between matching parentheses, handling arbitrary nesting.
+   * @param str - String starting with '('
+   * @returns Content between outer parens, or null if no match
+   */
+  static extractParenContent(str) {
+    if (!str.startsWith("(")) {
+      return null;
+    }
+    let depth = 0;
+    for (let i = 0; i < str.length; i++) {
+      if (str[i] === "(") {
+        depth++;
+      } else if (str[i] === ")") {
+        depth--;
+        if (depth === 0) {
+          return str.substring(1, i);
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Split parameter string by commas, respecting nested parentheses.
+   */
+  static splitParams(paramsStr) {
+    const params = [];
+    let current = "";
+    let depth = 0;
+    for (const char of paramsStr) {
+      if (char === "(") {
+        depth++;
+        current += char;
+      } else if (char === ")") {
+        depth--;
+        current += char;
+      } else if (char === "," && depth === 0) {
+        params.push(current.trim());
+        current = "";
+      } else {
+        current += char;
+      }
+    }
+    if (current.trim()) {
+      params.push(current.trim());
+    }
+    return params;
+  }
+  /**
+   * Parse a single parameter type string.
+   */
+  static parseParam(paramStr) {
+    const trimmed = paramStr.trim();
+    const isPointer = trimmed.includes("*");
+    const isConst = /\bconst\b/.test(trimmed) || trimmed.startsWith("const");
+    let baseType = trimmed.replaceAll(/\bconst\b/g, "").replace(/^const/, "").replaceAll("*", "").replaceAll(/\s+/g, " ").trim();
+    if (baseType.includes(" ")) {
+      baseType = baseType.replace(/\s+\w+$/, "");
+    }
+    if (baseType.startsWith("struct ")) {
+      baseType = baseType.substring(7);
+    }
+    return {
+      type: trimmed,
+      isPointer,
+      isConst,
+      baseType
+    };
+  }
+  /**
+   * Get the parameter info at a given index, or null if not found.
+   */
+  static getParamAt(typedefType, paramIndex) {
+    const parsed = _TypedefParamParser.parse(typedefType);
+    if (!parsed || paramIndex >= parsed.params.length) {
+      return null;
+    }
+    return parsed.params[paramIndex];
+  }
+  /**
+   * Check if a parameter at a given index should be a pointer based on the typedef.
+   *
+   * @param typedefType - The typedef type string
+   * @param paramIndex - The parameter index (0-based)
+   * @returns true if the param should be a pointer, false for value, null if unknown
+   */
+  static shouldBePointer(typedefType, paramIndex) {
+    return _TypedefParamParser.getParamAt(typedefType, paramIndex)?.isPointer ?? null;
+  }
+  /**
+   * Check if a parameter at a given index should be const based on the typedef.
+   *
+   * @param typedefType - The typedef type string
+   * @param paramIndex - The parameter index (0-based)
+   * @returns true if the param should be const, false otherwise, null if unknown
+   */
+  static shouldBeConst(typedefType, paramIndex) {
+    return _TypedefParamParser.getParamAt(typedefType, paramIndex)?.isConst ?? null;
+  }
+};
+var TypedefParamParser_default = TypedefParamParser;
+
 // src/transpiler/output/codegen/helpers/FunctionContextManager.ts
 var FunctionContextManager = class _FunctionContextManager {
   /**
@@ -125515,14 +125688,15 @@ var FunctionContextManager = class _FunctionContextManager {
   static processParameterList(params, callbacks) {
     CodeGenState.currentParameters.clear();
     if (!params) return;
-    for (const param of params.parameter()) {
-      _FunctionContextManager.processParameter(param, callbacks);
+    const paramList = params.parameter();
+    for (let i = 0; i < paramList.length; i++) {
+      _FunctionContextManager.processParameter(paramList[i], callbacks, i);
     }
   }
   /**
    * Process a single parameter declaration.
    */
-  static processParameter(param, callbacks) {
+  static processParameter(param, callbacks, paramIndex) {
     const name = param.IDENTIFIER().getText();
     const isArray = param.arrayDimension().length > 0 || param.type().arrayType() !== null;
     const isConst = param.constModifier() !== null;
@@ -125531,17 +125705,21 @@ var FunctionContextManager = class _FunctionContextManager {
       typeCtx,
       callbacks
     );
-    const isCallbackCompat = CodeGenState.currentFunctionName !== null && CodeGenState.callbackCompatibleFunctions.has(
-      CodeGenState.currentFunctionName
-    );
+    const callbackTypedefInfo = _FunctionContextManager.getCallbackTypedefParamInfo(paramIndex);
+    const isCallbackPointerParam = callbackTypedefInfo?.shouldBePointer ?? false;
+    const isStruct = callbackTypedefInfo ? isCallbackPointerParam && typeInfo.isStruct : typeInfo.isStruct;
+    const isCallbackPointerPrimitive = isCallbackPointerParam && !typeInfo.isStruct && !isArray;
     const paramInfo = {
       name,
       baseType: typeInfo.typeName,
       isArray,
-      isStruct: isCallbackCompat ? false : typeInfo.isStruct,
+      isStruct,
       isConst,
       isCallback: typeInfo.isCallback,
-      isString: typeInfo.isString
+      isString: typeInfo.isString,
+      isCallbackPointerPrimitive,
+      // Issue #895: Callback-compatible params need pointer semantics even in C++ mode
+      forcePointerSemantics: isCallbackPointerParam
     };
     CodeGenState.currentParameters.set(name, paramInfo);
     _FunctionContextManager.registerParameterType(
@@ -125704,6 +125882,32 @@ var FunctionContextManager = class _FunctionContextManager {
     }
     return dimensions;
   }
+  /**
+   * Issue #895: Get callback typedef parameter info from the C header.
+   * Returns null if not callback-compatible or index is invalid.
+   */
+  static getCallbackTypedefParamInfo(paramIndex) {
+    if (CodeGenState.currentFunctionName === null) return null;
+    const typedefName = CodeGenState.callbackCompatibleFunctions.get(
+      CodeGenState.currentFunctionName
+    );
+    if (!typedefName) return null;
+    const typedefType = CodeGenState.getTypedefType(typedefName);
+    if (!typedefType) return null;
+    const shouldBePointer = TypedefParamParser_default.shouldBePointer(
+      typedefType,
+      paramIndex
+    );
+    const shouldBeConst = TypedefParamParser_default.shouldBeConst(
+      typedefType,
+      paramIndex
+    );
+    if (shouldBePointer === null) return null;
+    return {
+      shouldBePointer,
+      shouldBeConst: shouldBeConst ?? false
+    };
+  }
   /**
    * Extract string capacity from a string type context.
    */
@@ -126496,7 +126700,8 @@ var ParameterInputAdapter = class {
     }
     const isKnownStruct = deps.isKnownStruct(typeName);
     const isKnownPrimitive = !!deps.typeMap[typeName];
-    const isAutoConst = !deps.isModified && !isConst;
+    const isAutoConst = !deps.isCallbackCompatible && !deps.isModified && !isConst;
+    const isPassByReference = deps.forcePassByReference || isKnownStruct || isKnownPrimitive;
     return {
       name,
       baseType: typeName,
@@ -126507,7 +126712,12 @@ var ParameterInputAdapter = class {
       isCallback: false,
       isString: false,
       isPassByValue: deps.isPassByValue,
-      isPassByReference: isKnownStruct || isKnownPrimitive
+      isPassByReference,
+      // Issue #895: Force pointer syntax in C++ mode for callback-compatible functions
+      // because C callback typedefs expect pointers, not C++ references
+      forcePointerSyntax: deps.forcePassByReference,
+      // Issue #895: Preserve const from callback typedef signature
+      forceConst: deps.forceConst
     };
   }
   /**
@@ -126721,11 +126931,15 @@ var ParameterSignatureBuilder = class {
   /**
    * Build pass-by-reference parameter signature.
    * C mode: const Point* p
-   * C++ mode: const Point& p
+   * C++ mode: const Point& p (unless forcePointerSyntax)
+   *
+   * Issue #895: When forcePointerSyntax is set, always use pointer syntax
+   * because C callback typedefs expect pointers, not C++ references.
    */
   static _buildRefParam(param, refSuffix) {
     const constPrefix = this._getConstPrefix(param);
-    return `${constPrefix}${param.mappedType}${refSuffix} ${param.name}`;
+    const actualSuffix = param.forcePointerSyntax ? "*" : refSuffix;
+    return `${constPrefix}${param.mappedType}${actualSuffix} ${param.name}`;
   }
   /**
    * Build unknown type parameter (pass by value, standard C semantics).
@@ -126735,13 +126949,15 @@ var ParameterSignatureBuilder = class {
     return `${constMod}${param.mappedType} ${param.name}`;
   }
   /**
-   * Get const prefix combining explicit const and auto-const.
-   * Auto-const is applied to unmodified parameters.
+   * Get const prefix combining explicit const, auto-const, and forced const.
+   * Priority: forceConst > isConst > isAutoConst
+   * Issue #895: forceConst preserves const from callback typedef signature.
    */
   static _getConstPrefix(param) {
-    const autoConst = param.isAutoConst && !param.isConst ? "const " : "";
-    const explicitConst = param.isConst ? "const " : "";
-    return `${autoConst}${explicitConst}`;
+    if (param.forceConst || param.isConst || param.isAutoConst) {
+      return "const ";
+    }
+    return "";
   }
 };
 var ParameterSignatureBuilder_default = ParameterSignatureBuilder;
@@ -127717,7 +127933,7 @@ var CodeGenerator = class _CodeGenerator {
   }
   /** Generate parameter list for function signature */
   generateParameterList(ctx) {
-    return ctx.parameter().map((p) => this.generateParameter(p)).join(", ");
+    return ctx.parameter().map((p, index) => this.generateParameter(p, index)).join(", ");
   }
   /** Get the raw type name without C conversion */
   getTypeName(ctx) {
@@ -129463,13 +129679,17 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
     const typedef = this.generateCallbackTypedef(name);
     return typedef ? functionCode + typedef : functionCode;
   }
-  generateParameter(ctx) {
+  generateParameter(ctx, paramIndex) {
     const typeName = this.getTypeName(ctx.type());
     const name = ctx.IDENTIFIER().getText();
     this._validateCStyleArrayParam(ctx, typeName, name);
     this._validateUnboundedArrayParam(ctx);
     const isModified = this._isCurrentParameterModified(name);
-    const isPassByValue = this._isPassByValueType(typeName, name);
+    const callbackInfo = paramIndex === void 0 ? null : FunctionContextManager_default.getCallbackTypedefParamInfo(paramIndex);
+    const isPassByValue = callbackInfo ? !callbackInfo.shouldBePointer : this._isPassByValueType(typeName, name);
+    const isCallbackCompatible = callbackInfo !== null;
+    const forcePassByReference = callbackInfo?.shouldBePointer ?? false;
+    const forceConst = callbackInfo?.shouldBeConst ?? false;
     const input = ParameterInputAdapter_default.fromAST(ctx, {
       getTypeName: (t) => this.getTypeName(t),
       generateType: (t) => this.generateType(t),
@@ -129478,7 +129698,10 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
       isKnownStruct: (t) => this.isKnownStruct(t),
       typeMap: TYPE_MAP_default,
       isModified,
-      isPassByValue
+      isPassByValue,
+      isCallbackCompatible,
+      forcePassByReference,
+      forceConst
     });
     return ParameterSignatureBuilder_default.build(input, CppModeHelper_default.refOrPtr());
   }
@@ -129816,14 +130039,18 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
     const isStructParam = paramInfo?.isStruct ?? false;
     const isCppAccess = hasGlobal && this.isCppScopeSymbol(firstId);
     const separatorDeps = this._buildMemberSeparatorDeps();
+    const forcePointerSemantics = paramInfo?.forcePointerSemantics ?? false;
     const separatorCtx = MemberSeparatorResolver_default.buildContext(
-      firstId,
-      hasGlobal,
-      hasThis,
-      CodeGenState.currentScope,
-      isStructParam,
-      separatorDeps,
-      isCppAccess
+      {
+        firstId,
+        hasGlobal,
+        hasThis,
+        currentScope: CodeGenState.currentScope,
+        isStructParam,
+        isCppAccess,
+        forcePointerSemantics
+      },
+      separatorDeps
     );
     return {
       generateExpression: (expr) => this.generateExpression(expr),
@@ -136890,6 +137117,11 @@ var FunctionCallAnalyzer = class {
       this.checkVarDeclForCallbackAssignment(varDecl);
       return;
     }
+    const exprStmt = stmt.expressionStatement();
+    if (exprStmt) {
+      this.checkExpressionForCallbackArgs(exprStmt.expression());
+      return;
+    }
     const ifStmt = stmt.ifStatement();
     if (ifStmt) {
       for (const child of ifStmt.statement()) {
@@ -136945,7 +137177,7 @@ var FunctionCallAnalyzer = class {
     if (!funcRef) return;
     const lookupName = funcRef.includes(".") ? funcRef.replace(".", "_") : funcRef;
     if (this.allLocalFunctions.has(lookupName)) {
-      CodeGenState.callbackCompatibleFunctions.add(lookupName);
+      CodeGenState.callbackCompatibleFunctions.set(lookupName, typeName);
     }
   }
   /**
@@ -136961,6 +137193,68 @@ var FunctionCallAnalyzer = class {
     }
     return null;
   }
+  /**
+   * Issue #895: Check expression for function calls that pass C-Next functions
+   * to C function pointer parameters.
+   *
+   * Pattern: `global.widget_set_flush_cb(w, my_flush)`
+   * Where widget_set_flush_cb's 2nd param is a C function pointer typedef.
+   */
+  checkExpressionForCallbackArgs(expr) {
+    const postfix = this.findPostfixExpression(expr);
+    if (!postfix) return;
+    const callInfo = this.extractCallInfo(postfix);
+    if (!callInfo) return;
+    const cFunc = this.symbolTable?.getCSymbol(callInfo.funcName);
+    if (cFunc?.kind !== "function" || !cFunc.parameters) return;
+    for (let i = 0; i < callInfo.args.length; i++) {
+      const param = cFunc.parameters[i];
+      if (!param) continue;
+      if (!this.isCFunctionPointerTypedef(param.type)) continue;
+      const funcRef = this.extractFunctionReference(callInfo.args[i]);
+      if (!funcRef) continue;
+      const lookupName = funcRef.includes(".") ? funcRef.replace(".", "_") : funcRef;
+      if (this.allLocalFunctions.has(lookupName)) {
+        CodeGenState.callbackCompatibleFunctions.set(lookupName, param.type);
+      }
+    }
+  }
+  /**
+   * Find the postfix expression within an expression tree.
+   * Uses ExpressionUnwrapper which validates that expression is "simple"
+   * (single term at each level), returning null for complex expressions.
+   */
+  findPostfixExpression(expr) {
+    return ExpressionUnwrapper_default.getPostfixExpression(expr);
+  }
+  /**
+   * Extract function name and arguments from a postfix expression.
+   * Returns null if not a function call.
+   */
+  extractCallInfo(postfix) {
+    const primary = postfix.primaryExpression();
+    const ops = postfix.postfixOp();
+    const ident = primary.IDENTIFIER();
+    const globalKw = primary.GLOBAL();
+    if (!ident && !globalKw) {
+      return null;
+    }
+    let funcName = ident ? ident.getText() : "";
+    let argListOp = null;
+    for (const op of ops) {
+      if (op.IDENTIFIER()) {
+        const member = op.IDENTIFIER().getText();
+        funcName = funcName ? `${funcName}_${member}` : member;
+      } else if (op.argumentList() || op.getText().startsWith("(")) {
+        argListOp = op;
+        break;
+      }
+    }
+    if (!argListOp || !funcName) return null;
+    const argList = argListOp.argumentList();
+    const args = argList?.expression() ?? [];
+    return { funcName, args };
+  }
   /**
    * ADR-040: Register a variable that holds a callable (ISR or callback)
    */
@@ -138627,7 +138921,7 @@ var Transpiler = class {
     this.state.reset();
     CodeGenState.symbolTable.clear();
     SymbolRegistry_default.reset();
-    CodeGenState.callbackCompatibleFunctions = /* @__PURE__ */ new Set();
+    CodeGenState.callbackCompatibleFunctions = /* @__PURE__ */ new Map();
   }
   /**
    * Ensure output directories exist