@typecad/cuttlefish 0.1.0-alpha.1

package/dist/create/eslint-rules-template.js

@@ -0,0 +1,672 @@
+export function generateEslintRules(_options) {
+    return `// ---------------------------------------------------------------------------
+// ESLint Custom Rules - Cuttlefish transpiler compatibility
+//
+// Context-sensitive checks that cannot be expressed as no-restricted-syntax
+// selectors.  These rules use AST analysis to detect patterns that the
+// transpiler cannot handle or only approximates.
+//
+// Auto-generated by 'cuttlefish create'.  Do not edit manually.
+// ---------------------------------------------------------------------------
+
+const MAP_LIKE_RE = /^[A-Z]/;
+
+export default {
+  rules: {
+    "no-delete-non-map": {
+      meta: {
+        type: "problem",
+        docs: {
+          description:
+            "[transpiler] delete on non-map types is unsupported in C++.",
+        },
+      },
+      create(context) {
+        return {
+          "UnaryExpression[operator='delete']"(node) {
+            const arg = node.argument;
+            if (arg.type === "MemberExpression" && arg.computed) {
+              if (
+                arg.object.type === "Identifier" &&
+                (MAP_LIKE_RE.test(arg.object.name) ||
+                  arg.object.name === "this")
+              ) {
+                return;
+              }
+            }
+            context.report({
+              node,
+              message:
+                "[transpiler] delete on non-map types is unsupported in C++. Use a Map and its .delete() method.",
+            });
+          },
+        };
+      },
+    },
+
+    "no-object-static-non-map": {
+      meta: {
+        type: "problem",
+        docs: {
+          description:
+            "[transpiler] Object.keys/values/entries on non-map types is unsupported.",
+        },
+      },
+      create(context) {
+        const METHODS = new Set(["keys", "values", "entries"]);
+        return {
+          CallExpression(node) {
+            const callee = node.callee;
+            if (
+              callee.type === "MemberExpression" &&
+              !callee.computed &&
+              callee.object.type === "Identifier" &&
+              callee.object.name === "Object" &&
+              callee.property.type === "Identifier" &&
+              METHODS.has(callee.property.name)
+            ) {
+              if (node.arguments.length > 0) {
+                const arg = node.arguments[0];
+                // Exempt a bare identifier whose name looks map-like (capitalized
+                // first letter) — the transpiler resolves it to std::map.
+                if (
+                  arg.type === "Identifier" &&
+                  MAP_LIKE_RE.test(arg.name) &&
+                  arg.name !== "Object"
+                ) {
+                  return;
+                }
+                // Exempt a member-access argument (this.field, obj.field). The
+                // transpiler resolves the field's declared type and emits the
+                // __tc_mapKeys/Values/Entries helper when it's a std::map.
+                if (
+                  arg.type === "MemberExpression" &&
+                  !arg.computed &&
+                  arg.property.type === "Identifier"
+                ) {
+                  return;
+                }
+              }
+              context.report({
+                node,
+                message:
+                  "[transpiler] Object." +
+                  callee.property.name +
+                  " on non-map types is unsupported. Use a Map and iterate with .keys(), .values(), or .entries().",
+              });
+            }
+          },
+        };
+      },
+    },
+
+    "no-super-outside-method": {
+      meta: {
+        type: "problem",
+        docs: {
+          description:
+            "[transpiler] super keyword outside class method context has no valid C++ translation.",
+        },
+      },
+      create(context) {
+        return {
+          Super(node) {
+            let foundValid = false;
+            let current = node.parent;
+            while (current) {
+              if (
+                current.type === "MethodDefinition" ||
+                current.type === "FunctionExpression" ||
+                current.type === "StaticBlock"
+              ) {
+                let classBody = current.parent;
+                if (classBody && classBody.type === "MethodDefinition") {
+                  classBody = classBody.parent;
+                }
+                if (classBody && classBody.type === "ClassBody") {
+                  const classDecl = classBody.parent;
+                  if (
+                    classDecl &&
+                    (classDecl.type === "ClassDeclaration" ||
+                      classDecl.type === "ClassExpression") &&
+                    classDecl.superClass
+                  ) {
+                    foundValid = true;
+                  }
+                }
+                break;
+              }
+              if (
+                current.type === "ClassBody" ||
+                current.type === "ClassDeclaration" ||
+                current.type === "ClassExpression"
+              ) {
+                break;
+              }
+              current = current.parent;
+            }
+            if (!foundValid) {
+              context.report({
+                node,
+                message:
+                  "[transpiler] super keyword outside of class method context has no valid C++ translation.",
+              });
+            }
+          },
+        };
+      },
+    },
+
+    "no-typeof-non-primitive": {
+      meta: {
+        type: "problem",
+        docs: {
+          description:
+            "[transpiler] typeof on non-primitive types returns an approximate type name in C++.",
+        },
+      },
+      create(context) {
+        return {
+          "UnaryExpression[operator='typeof']"(node) {
+            const arg = node.argument;
+            if (
+              arg.type === "MemberExpression" ||
+              arg.type === "CallExpression" ||
+              arg.type === "ObjectExpression"
+            ) {
+              context.report({
+                node,
+                message:
+                  "[transpiler] typeof on non-primitive types returns an approximate type name in C++. Use type guards or instanceof instead.",
+              });
+            }
+          },
+        };
+      },
+    },
+
+    "no-destructured-without-init": {
+      meta: {
+        type: "problem",
+        docs: {
+          description:
+            "[transpiler] Destructuring declarations without initializers are unsupported.",
+        },
+      },
+      create(context) {
+        return {
+          VariableDeclarator(node) {
+            if (
+              (node.id.type === "ObjectPattern" ||
+                node.id.type === "ArrayPattern") &&
+              !node.init
+            ) {
+              context.report({
+                node,
+                message:
+                  "[transpiler] Destructuring declaration without an initializer is unsupported in C++. Provide a default value or initializer.",
+              });
+            }
+          },
+        };
+      },
+    },
+
+    "no-fractional-to-number-type": {
+      meta: {
+        type: "problem",
+        docs: {
+          description:
+            "[transpiler] Fractional literals assigned to 'number'-typed variables/fields are truncated to integers in C++.",
+        },
+      },
+      create(context) {
+        function isNumberType(typeNode) {
+          if (!typeNode) return false;
+          if (typeNode.type === "TSNumberKeyword") return true;
+          if (typeNode.type === "TSTypeAnnotation" && typeNode.typeAnnotation) {
+            return isNumberType(typeNode.typeAnnotation);
+          }
+          return false;
+        }
+        function isFractionalLiteral(node) {
+          if (node.type === "Literal" && typeof node.value === "number") {
+            return !Number.isInteger(node.value);
+          }
+          if (node.type === "UnaryExpression" && node.operator === "-" && node.argument) {
+            return isFractionalLiteral(node.argument);
+          }
+          return false;
+        }
+        function checkFractionalInitializer(node, typeAnnotation, init) {
+          if (!typeAnnotation || !init) return;
+          if (!isNumberType(typeAnnotation)) return;
+          if (!isFractionalLiteral(init)) return;
+          context.report({
+            node,
+            message:
+              "[transpiler] Fractional value " + init.raw +
+              " is truncated when assigned to 'number' type. Use 'double' or 'float' to preserve fractional precision.",
+          });
+        }
+        return {
+          PropertyDefinition(node) {
+            if (node.typeAnnotation && node.value) {
+              checkFractionalInitializer(node, node.typeAnnotation, node.value);
+            }
+          },
+          VariableDeclarator(node) {
+            if (node.id.typeAnnotation && node.init) {
+              checkFractionalInitializer(node, node.id.typeAnnotation, node.init);
+            }
+          },
+        };
+      },
+    },
+
+    "no-array-param-content-mutation": {
+      meta: {
+        type: "problem",
+        docs: {
+          description:
+            "[transpiler] Mutating an array parameter's contents has no effect in C++ (the parameter is a by-value std::vector copy).",
+        },
+      },
+      create(context) {
+        return {};
+      },
+    },
+
+    "no-container-functional-methods": {
+      meta: {
+        type: "problem",
+        docs: {
+          description:
+            "[transpiler] Functional array methods (.forEach/.map/.filter/.reduce) are not lowered on Map/Set/Record.",
+        },
+      },
+      create(context) {
+        const FUNCTIONAL_METHODS = new Set([
+          "forEach", "map", "filter", "reduce", "reduceRight",
+          "find", "findIndex", "findLast", "some", "every", "flatMap",
+        ]);
+        const CONTAINER_TYPE_RE = /^(Map|Set|ReadonlyMap|ReadonlySet|Record|WeakMap|WeakSet)\\b/;
+        const containerVars = new Map();
+        function typeText(node) {
+          if (!node) return "";
+          if (node.type === "TSTypeAnnotation" && node.typeAnnotation) return typeText(node.typeAnnotation);
+          if (node.type === "TSTypeReference" && node.typeName) return node.typeName.type === "Identifier" ? node.typeName.name : typeText(node.typeName);
+          if (node.type === "TSMapLikeType") return "Map";
+          return "";
+        }
+        function isContainerVar(node) {
+          if (node.type === "Identifier" && containerVars.has(node.name)) return true;
+          if (node.type === "CallExpression" && node.callee.type === "MemberExpression" && node.callee.property.type === "Identifier" && FUNCTIONAL_METHODS.has(node.callee.property.name)) return true;
+          return false;
+        }
+        return {
+          VariableDeclarator(node) {
+            if (node.id.type !== "Identifier") return;
+            const name = node.id.name;
+            if (node.id.typeAnnotation) {
+              const t = typeText(node.id.typeAnnotation);
+              if (CONTAINER_TYPE_RE.test(t)) { containerVars.set(name, true); return; }
+            }
+            if (node.init && node.init.type === "NewExpression" && node.init.callee.type === "Identifier" && CONTAINER_TYPE_RE.test(node.init.callee.name)) {
+              containerVars.set(name, true);
+            }
+          },
+          CallExpression(node) {
+            const callee = node.callee;
+            if (callee.type !== "MemberExpression" || callee.computed || callee.property.type !== "Identifier" || !FUNCTIONAL_METHODS.has(callee.property.name)) return;
+            if (isContainerVar(callee.object)) {
+              context.report({ node, message: "[transpiler] ." + callee.property.name + "() is not lowered on Map/Set/Record. Iterate a parallel key array with for...of instead." });
+            }
+          },
+        };
+      },
+    },
+
+    "no-undefined-compare-on-get": {
+      meta: {
+        type: "problem",
+        docs: {
+          description:
+            "[transpiler] Comparing a .get() result to undefined/null does not lower to valid C++.",
+        },
+      },
+      create(context) {
+        const UNDEF_NULL_OPS = new Set(["==", "!=", "===", "!=="]);
+        function isUndefinedOrNull(node) {
+          if (node.type === "Identifier" && (node.name === "undefined" || node.name === "null")) return true;
+          if (node.type === "Literal" && node.value === null) return true;
+          return false;
+        }
+        function isGetCall(node) {
+          return node.type === "CallExpression" && node.callee.type === "MemberExpression" && !node.callee.computed && node.callee.property.type === "Identifier" && (node.callee.property.name === "get" || node.callee.property.name === "at");
+        }
+        return {
+          BinaryExpression(node) {
+            if (!UNDEF_NULL_OPS.has(node.operator)) return;
+            const leftUndef = isUndefinedOrNull(node.left);
+            const rightUndef = isUndefinedOrNull(node.right);
+            if (!leftUndef && !rightUndef) return;
+            const otherSide = leftUndef ? node.right : node.left;
+            if (isGetCall(otherSide)) {
+              context.report({ node, message: "[transpiler] Comparing ." + otherSide.callee.property.name + "() to undefined/null does not lower to valid C++. Guard with .has(key) before .get(key)." });
+            }
+          },
+        };
+      },
+    },
+
+    "no-map-struct-mutation": {
+      meta: {
+        type: "problem",
+        docs: {
+          description:
+            "[transpiler] Mutating a field of a value fetched via Map.get()/.at() is lost (or a compile error) in C++ — the value is a copy. Use a separate primitive Map and .set() back.",
+        },
+      },
+      create(context) {
+        const getBindings = new Set();
+        function isContainerGetCall(node) {
+          return node.type === "CallExpression" && node.callee.type === "MemberExpression" && !node.callee.computed && node.callee.property.type === "Identifier" && (node.callee.property.name === "get" || node.callee.property.name === "at");
+        }
+        function reportIfMutatingGetBinding(node, target) {
+          if (target.type !== "MemberExpression") return;
+          if (target.object.type === "Identifier" && getBindings.has(target.object.name)) {
+            const propName = target.property.type === "Identifier" ? target.property.name : "[...]";
+            context.report({ node, message: "[transpiler] '" + target.object.name + "' is a value fetched from a Map; mutating its '" + propName + "' field is lost in C++ (the binding is a copy). Use a separate primitive Map and .set() back, or erase + re-insert the struct." });
+          }
+        }
+        return {
+          VariableDeclarator(node) {
+            if (node.init && isContainerGetCall(node.init) && node.id.type === "Identifier") {
+              getBindings.add(node.id.name);
+            }
+          },
+          AssignmentExpression(node) { reportIfMutatingGetBinding(node, node.left); },
+          UpdateExpression(node) { reportIfMutatingGetBinding(node, node.argument); },
+        };
+      },
+    },
+
+    "no-undefined-compare-on-struct-field": {
+      meta: {
+        type: "problem",
+        docs: {
+          description:
+            "[transpiler] Comparing a struct/interface field to undefined/null does not lower to valid C++ (optional fields flatten to T). Use an explicit boolean flag.",
+        },
+      },
+      create(context) {
+        const UNDEF_NULL_OPS = new Set(["==", "!=", "===", "!=="]);
+        function isUndefinedOrNull(node) {
+          if (node.type === "Identifier" && (node.name === "undefined" || node.name === "null")) return true;
+          if (node.type === "Literal" && node.value === null) return true;
+          return false;
+        }
+        function isMemberAccess(node) {
+          return node.type === "MemberExpression" && !node.computed;
+        }
+        return {
+          BinaryExpression(node) {
+            if (!UNDEF_NULL_OPS.has(node.operator)) return;
+            const leftUndef = isUndefinedOrNull(node.left);
+            const rightUndef = isUndefinedOrNull(node.right);
+            if (!leftUndef && !rightUndef) return;
+            const otherSide = leftUndef ? node.right : node.left;
+            if (isMemberAccess(otherSide)) {
+              const propName = otherSide.property.type === "Identifier" ? otherSide.property.name : "<computed>";
+              context.report({ node, message: "[transpiler] Comparing ." + propName + " to undefined/null does not lower to valid C++ (optional struct/interface fields flatten to their value type). Use an explicit boolean flag on the interface instead of an optional field." });
+            }
+          },
+        };
+      },
+    },
+
+    "no-typed-array-param-length": {
+      meta: {
+        type: "problem",
+        docs: {
+          description:
+            "[transpiler] .length on a typed-array parameter does not lower to valid C++.",
+        },
+      },
+      create(context) {
+        const TYPED_ARRAYS = new Set(["Uint8Array", "Int8Array", "Uint16Array", "Int16Array", "Uint32Array", "Int32Array", "Float32Array", "Float64Array", "BigUint64Array", "BigInt64Array"]);
+        const typedArrayParams = new Set();
+        function isTypedArrayTypeAnnotation(typeAnnotation) {
+          if (!typeAnnotation) return false;
+          let t = typeAnnotation;
+          if (t.type === "TSTypeAnnotation") t = t.typeAnnotation;
+          if (t && t.type === "TSTypeReference" && t.typeName.type === "Identifier") return TYPED_ARRAYS.has(t.typeName.name);
+          return false;
+        }
+        function registerParams(params) {
+          for (const p of params) {
+            if (p.type === "Identifier" && isTypedArrayTypeAnnotation(p.typeAnnotation)) typedArrayParams.add(p.name);
+          }
+        }
+        return {
+          FunctionDeclaration: (node) => registerParams(node.params),
+          FunctionExpression: (node) => registerParams(node.params),
+          ArrowFunctionExpression: (node) => registerParams(node.params),
+          MemberExpression(node) {
+            if (!node.computed && node.object.type === "Identifier" && typedArrayParams.has(node.object.name) && node.property.type === "Identifier" && node.property.name === "length") {
+              context.report({ node, message: "[transpiler] ." + node.object.name + ".length on a typed-array parameter does not lower to valid C++. Pass the length explicitly." });
+            }
+          },
+        };
+      },
+    },
+
+    "no-typed-array-return": {
+      meta: {
+        type: "problem",
+        docs: {
+          description:
+            "[transpiler] Returning a typed array dangles (lowers to a pointer to a stack-local).",
+        },
+      },
+      create(context) {
+        const TYPED_ARRAYS = new Set(["Uint8Array", "Int8Array", "Uint16Array", "Int16Array", "Uint32Array", "Int32Array", "Float32Array", "Float64Array", "BigUint64Array", "BigInt64Array"]);
+        function isTypedArrayAnnotation(typeAnnotation) {
+          if (!typeAnnotation) return false;
+          let t = typeAnnotation;
+          if (t.type === "TSTypeAnnotation") t = t.typeAnnotation;
+          if (t && t.type === "TSTypeReference" && t.typeName.type === "Identifier") return TYPED_ARRAYS.has(t.typeName.name);
+          return false;
+        }
+        function checkReturnType(node) {
+          if (node.returnType && isTypedArrayAnnotation(node.returnType)) {
+            context.report({ node: node.returnType, message: "[transpiler] Returning a typed array dangles in C++. Use an out-parameter instead." });
+          }
+        }
+        return {
+          FunctionDeclaration: checkReturnType,
+          FunctionExpression: checkReturnType,
+          ArrowFunctionExpression: checkReturnType,
+        };
+      },
+    },
+
+    "no-typed-array-field": {
+      meta: {
+        type: "problem",
+        docs: {
+          description:
+            "[transpiler] A typed-array class field has no safe C++ lowering (pointer-like storage with no owned buffer).",
+        },
+      },
+      create(context) {
+        const TYPED_ARRAYS = new Set(["Uint8Array", "Int8Array", "Uint16Array", "Int16Array", "Uint32Array", "Int32Array", "Float32Array", "Float64Array", "BigUint64Array", "BigInt64Array"]);
+        function isTypedArrayAnnotation(typeAnnotation) {
+          if (!typeAnnotation) return false;
+          let t = typeAnnotation;
+          if (t.type === "TSTypeAnnotation") t = t.typeAnnotation;
+          if (t && t.type === "TSTypeReference" && t.typeName.type === "Identifier") return TYPED_ARRAYS.has(t.typeName.name);
+          return false;
+        }
+        return {
+          PropertyDefinition(node) {
+            if (node.typeAnnotation && isTypedArrayAnnotation(node.typeAnnotation)) {
+              context.report({ node: node.typeAnnotation, message: "[transpiler] A typed-array class field has no owned backing buffer in C++. Use a function-local typed array for a stack buffer, or store the data in a number[]/int8_t[] field (a std::vector) that owns its storage." });
+            }
+          },
+        };
+      },
+    },
+
+    "no-dynamic-property-access": {
+      meta: {
+        type: "problem",
+        docs: {
+          description:
+            "[transpiler] Dynamic string-key property access (obj[key]) on non-map types is not reliably lowered.",
+        },
+      },
+      create(context) {
+        function isNumericLiteral(node) {
+          return node.type === "Literal" && (typeof node.value === "number" || /^-?\\d+$/.test(String(node.value)));
+        }
+        function isStringLiteral(node) {
+          return node.type === "Literal" && typeof node.value === "string";
+        }
+        return {
+          "MemberExpression[computed=true]"(node) {
+            if (isNumericLiteral(node.property)) return;
+            if (!isStringLiteral(node.property)) return;
+            if (node.object.type === "Identifier" && (MAP_LIKE_RE.test(node.object.name) || node.object.name === "this")) return;
+            context.report({ node, message: "[transpiler] dynamic string-key access (obj[\\\"key\\\"]) on non-map types is not reliably lowered. Use a Map<string, T> for dynamic keys, or a numeric index for arrays." });
+          },
+        };
+      },
+    },
+
+    "no-mutating-method-on-const-collection": {
+      meta: {
+        type: "problem",
+        docs: {
+          description:
+            "[transpiler] A const-bound Map/Set mutated via .set()/.add()/.delete()/.clear() is demoted to non-const in C++. Prefer a let binding to express intent, or avoid mutating a collection you declared const.",
+        },
+      },
+      create(context) {
+        // const bindings whose declared type is Map/Set/ReadonlyMap/ReadonlySet.
+        const constCollections = new Map(); // name -> typeName
+        const COLLECTION_TYPES = new Set(["Map", "Set", "ReadonlyMap", "ReadonlySet"]);
+        const MUTATORS = new Set(["set", "add", "delete", "clear"]);
+        function collectionName(typeAnnotation) {
+          if (!typeAnnotation) return null;
+          let t = typeAnnotation;
+          if (t.type === "TSTypeAnnotation") t = t.typeAnnotation;
+          if (t && t.type === "TSTypeReference" && t.typeName.type === "Identifier" && COLLECTION_TYPES.has(t.typeName.name)) {
+            return t.typeName.name;
+          }
+          return null;
+        }
+        return {
+          VariableDeclarator(node) {
+            if (node.parent && node.parent.kind === "const" && node.id.type === "Identifier") {
+              const cName = collectionName(node.id.typeAnnotation);
+              if (cName) constCollections.set(node.id.name, cName);
+            }
+          },
+          CallExpression(node) {
+            const callee = node.callee;
+            if (callee.type !== "MemberExpression" || callee.computed) return;
+            if (callee.object.type !== "Identifier") return;
+            if (!constCollections.has(callee.object.name)) return;
+            if (callee.property.type !== "Identifier" || !MUTATORS.has(callee.property.name)) return;
+            context.report({ node, message: "[transpiler] '" + callee.object.name + "' is a const " + constCollections.get(callee.object.name) + " mutated via ." + callee.property.name + "() — the C++ binding is demoted to non-const. Declare it with a let binding to express the mutation intent, or avoid mutating a collection you declared const." });
+          },
+        };
+      },
+    },
+
+    // A const for/for-in loop variable mutated in the body is demoted to a
+    // non-const C++ reference (T&) by the transpiler. Surface it at lint time
+    // so the author can express the intent with a let binding. (demo #17 fix)
+    "no-readonly-loop-variable-mutation": {
+      meta: {
+        type: "problem",
+        docs: {
+          description:
+            "[transpiler] A const for/for-in loop variable mutated in the body is demoted to a non-const reference in C++. Prefer a let binding to express the mutation intent.",
+        },
+      },
+      create(context) {
+        // Stack of active const loop-variable names, scoped to each loop body.
+        const loopVarStack = [];
+        function baseIdentifierName(node) {
+          if (!node) return null;
+          if (node.type !== "MemberExpression") return null;
+          const obj = node.object;
+          if (obj.type === "Identifier") return obj.name;
+          return null;
+        }
+        function reportIfLoopVar(target, node) {
+          const name = baseIdentifierName(target);
+          if (!name) return;
+          const top = loopVarStack[loopVarStack.length - 1];
+          if (top && top.has(name)) {
+            context.report({ node, message: "[transpiler] '" + name + "' is a const loop variable mutated in the loop body — the C++ binding is demoted to a non-const reference (T&). Use a let binding to express the mutation intent." });
+          }
+        }
+        function pushLoopVars(node) {
+          const decl = node.left;
+          if (decl && decl.type === "VariableDeclaration" && decl.kind === "const") {
+            const names = new Set();
+            for (const d of decl.declarations) {
+              if (d.id && d.id.type === "Identifier") names.add(d.id.name);
+            }
+            loopVarStack.push(names);
+          } else {
+            loopVarStack.push(new Set());
+          }
+        }
+        return {
+          ForOfStatement(node) { pushLoopVars(node); },
+          "ForOfStatement:exit"() { loopVarStack.pop(); },
+          ForInStatement(node) { pushLoopVars(node); },
+          "ForInStatement:exit"() { loopVarStack.pop(); },
+          AssignmentExpression(node) { reportIfLoopVar(node.left, node); },
+          UpdateExpression(node) { reportIfLoopVar(node.argument, node); },
+        };
+      },
+    },
+
+    "no-this-in-free-function": {
+      meta: {
+        type: "problem",
+        docs: {
+          description:
+            "[transpiler] \`this\` in a free function has no fixed C++ this pointer to lower to.",
+        },
+      },
+      create(context) {
+        return {
+          ThisExpression(node) {
+            let current = node.parent;
+            while (current) {
+              if (current.type === "MethodDefinition") return;
+              if (current.type === "PropertyDefinition") return;
+              if (current.type === "StaticBlock") return;
+              if (current.type === "FunctionExpression" && current.parent && (current.parent.type === "MethodDefinition" || current.parent.type === "PropertyDefinition")) return;
+              if (current.type === "ArrowFunctionExpression") { current = current.parent; continue; }
+              if (current.type === "FunctionDeclaration" || current.type === "FunctionExpression") {
+                context.report({ node, message: "[transpiler] \`this\` in a free function has no fixed C++ this pointer to lower to. Move the code into a class method, or pass the value as a parameter." });
+                return;
+              }
+              current = current.parent;
+            }
+          },
+        };
+      },
+    },
+  },
+};
+`;
+}

package/dist/create/index.d.ts

@@ -0,0 +1,11 @@
+export { scaffoldProject, normalizeProjectName, KNOWN_TARGETS, KNOWN_BOARDS, registerKnownTarget, printInitNextSteps } from './init-scaffold.js';
+export type { KnownTarget, KnownBoard, ScaffoldProjectResult } from './init-scaffold.js';
+export { generateProjectPackageJson, generateProjectTsconfig, generateProjectConfig, generateProjectEnvDts, generateStarterSketch, generateGitignore, generateEslintConfig, } from './init-templates.js';
+export type { InitProjectOptions } from './init-templates.js';
+export { runInitWizard } from './init-wizard.js';
+export { scaffoldBoardPackages } from './board-codegen.js';
+export type { ScaffoldBoardResult } from './board-codegen.js';
+export { generateFrameworkChecklist } from './board-checklist.js';
+export { parseBoardSpec, safeParseBoardSpec, stripJsonc, BoardSpecSchema } from './board-spec.js';
+export type { BoardSpec } from './board-spec.js';
+export * as BoardGenerators from './board-generators.js';