deps: update ata to 0.10.6

Author: mertcanaltin

deps/ata/ata.cpp

@@ -1,3 +1,5 @@
+/* auto-generated on 2026-04-30 21:36:25 +0300. Do not edit! */
+/* begin file src/ata.cpp */
 #include "ata.h"
 
 // mimalloc: faster new/delete for small allocations.
@@ -1016,6 +1018,69 @@ static schema_node_ptr find_anchor_in_resource(const compiled_schema& ctx,
   return nullptr;
 }
 
+// Returns cap + 1 once the running row minimum exceeds cap (early reject).
+static size_t lev_capped(std::string_view a, std::string_view b, size_t cap) {
+  if (a == b) return 0;
+  size_t la = a.size();
+  size_t lb = b.size();
+  if (la > lb) {
+    std::swap(a, b);
+    std::swap(la, lb);
+  }
+  if (lb - la > cap) return cap + 1;
+
+  std::vector<size_t> prev(la + 1);
+  std::vector<size_t> curr(la + 1);
+  for (size_t i = 0; i <= la; ++i) prev[i] = i;
+
+  for (size_t j = 1; j <= lb; ++j) {
+    curr[0] = j;
+    size_t row_min = j;
+    for (size_t i = 1; i <= la; ++i) {
+      size_t cost = (a[i - 1] == b[j - 1]) ? 0 : 1;
+      size_t v = std::min({prev[i] + 1, curr[i - 1] + 1, prev[i - 1] + cost});
+      curr[i] = v;
+      if (v < row_min) row_min = v;
+    }
+    if (row_min > cap) return cap + 1;
+    std::swap(prev, curr);
+  }
+  return prev[la];
+}
+
+// Edit-distance up to 2 wins; otherwise fall back to a common-prefix match
+// (covers renames like "testRunner" vs "test" where edit distance is large).
+static std::string suggest_property(
+    std::string_view rejected,
+    const std::unordered_map<std::string, schema_node_ptr>& properties) {
+  if (properties.empty() || rejected.empty()) return "";
+
+  std::string best;
+  size_t best_dist = 3;
+  size_t best_prefix = 0;
+
+  for (const auto& [key, _] : properties) {
+    if (key.empty()) continue;
+    size_t d = lev_capped(rejected, key, 2);
+    if (d <= 2 && d < best_dist) {
+      best = key;
+      best_dist = d;
+      continue;
+    }
+    if (best_dist > 2) {
+      size_t maxp = std::min(rejected.size(), key.size());
+      size_t pl = 0;
+      while (pl < maxp && rejected[pl] == key[pl]) ++pl;
+      size_t shorter = std::min(rejected.size(), key.size());
+      if (pl >= 3 && pl * 2 >= shorter && pl > best_prefix) {
+        best = key;
+        best_prefix = pl;
+      }
+    }
+  }
+  return best;
+}
+
 static void validate_node(const schema_node_ptr& node,
                            dom::element value,
                            const std::string& path,
@@ -1619,9 +1684,13 @@ static void validate_node(const schema_node_ptr& node,
       if (!matched) {
         if (node->additional_properties_bool.has_value() &&
             !node->additional_properties_bool.value()) {
+          std::string msg = "additional property not allowed: " + key_str;
+          std::string suggestion = suggest_property(key_str, node->properties);
+          if (!suggestion.empty()) {
+            msg += ". did you mean \"" + suggestion + "\"?";
+          }
           errors.push_back(
-              {error_code::additional_property_not_allowed, path,
-               "additional property not allowed: " + key_str});
+              {error_code::additional_property_not_allowed, path, msg});
         } else if (node->additional_properties_schema) {
           validate_node(node->additional_properties_schema, val,
                         path + "/" + key_str, ctx, errors, all_errors, dynamic_scope);
@@ -2815,3 +2884,4 @@ bool is_valid_buf(const schema_ref& schema, const uint8_t* data, size_t length)
 }
 
 }  // namespace ata
+/* end file src/ata.cpp */

deps/ata/ata.h

@@ -1,3 +1,5 @@
+/* auto-generated on 2026-04-30 21:36:25 +0300. Do not edit! */
+/* begin file include/ata.h */
 #pragma once
 
 #include <cstdint>
@@ -8,16 +10,16 @@
 #include <variant>
 #include <vector>
 
-#define ATA_VERSION "0.10.5"
+#define ATA_VERSION "0.10.6"
 
 namespace ata {
 
 inline constexpr uint32_t VERSION_MAJOR = 0;
 inline constexpr uint32_t VERSION_MINOR = 10;
-inline constexpr uint32_t VERSION_REVISION = 5;
+inline constexpr uint32_t VERSION_REVISION = 6;
 
 inline constexpr std::string_view version() noexcept {
-  return "0.10.5";
+  return "0.10.6";
 }
 
 enum class error_code : uint8_t {
@@ -112,3 +114,4 @@ bool is_valid_buf(const schema_ref& schema, const uint8_t* data, size_t length);
 inline constexpr size_t REQUIRED_PADDING = 64;
 
 }  // namespace ata
+/* end file include/ata.h */

src/node_config_file.cc

@@ -239,7 +239,7 @@ ParseResult ConfigReader::ParseConfig(const std::string_view& config_path) {
 
   {
     static const ata::schema_ref compiled_schema =
-        ata::compile(options_parser::GenerateConfigJsonSchema(false));
+        ata::compile(options_parser::GenerateConfigJsonSchema());
     CHECK(compiled_schema);
     auto result = ata::validate(compiled_schema, file_content);
     if (!result.valid) {

src/node_options.cc

@@ -1766,13 +1766,9 @@ std::vector<std::pair<std::string, OptionMappingDetails>> SortedOptionEntries(
 
 void AppendNodeOptionsObject(
     std::string* out,
-    const std::vector<std::pair<std::string, OptionMappingDetails>>& sorted_env,
-    bool include_additional_properties) {
-  *out += '{';
-  if (include_additional_properties) {
-    *out += R"("additionalProperties":false,)";
-  }
-  *out += R"("required":[],"properties":{)";
+    const std::vector<std::pair<std::string, OptionMappingDetails>>&
+        sorted_env) {
+  *out += R"({"additionalProperties":false,"required":[],"properties":{)";
   bool first = true;
   for (const auto& entry : sorted_env) {
     if (!first) *out += ',';
@@ -1786,13 +1782,9 @@ void AppendNodeOptionsObject(
 
 void AppendNamespaceObject(
     std::string* out,
-    const std::unordered_map<std::string, OptionMappingDetails>& options,
-    bool include_additional_properties) {
+    const std::unordered_map<std::string, OptionMappingDetails>& options) {
   auto sorted = SortedOptionEntries(options);
-  *out += R"({"type":"object",)";
-  if (include_additional_properties) {
-    *out += R"("additionalProperties":false,)";
-  }
+  *out += R"({"type":"object","additionalProperties":false,)";
   *out += R"("required":[],"properties":{)";
   bool first = true;
   for (const auto& entry : sorted) {
@@ -1807,7 +1799,7 @@ void AppendNamespaceObject(
 
 }  // namespace
 
-std::string GenerateConfigJsonSchema(bool include_additional_properties) {
+std::string GenerateConfigJsonSchema() {
   Mutex::ScopedLock lock(per_process::cli_options_mutex);
 
   auto env_options = MapEnvOptionsFlagInputType();
@@ -1826,9 +1818,7 @@ std::string GenerateConfigJsonSchema(bool include_additional_properties) {
 
   out += '{';
   out += R"("$schema":"https://json-schema.org/draft/2020-12/schema",)";
-  if (include_additional_properties) {
-    out += R"("additionalProperties":false,)";
-  }
+  out += R"("additionalProperties":false,)";
   out += R"("required":[],"properties":{)";
 
   bool first_prop = true;
@@ -1841,10 +1831,9 @@ std::string GenerateConfigJsonSchema(bool include_additional_properties) {
     if (prop == "$schema") {
       out += R"({"type":"string"})";
     } else if (prop == "nodeOptions") {
-      AppendNodeOptionsObject(&out, sorted_env, include_additional_properties);
+      AppendNodeOptionsObject(&out, sorted_env);
     } else {
-      AppendNamespaceObject(
-          &out, namespace_options.at(prop), include_additional_properties);
+      AppendNamespaceObject(&out, namespace_options.at(prop));
     }
   }
 
@@ -2313,7 +2302,7 @@ void GetOptionsAsFlags(const FunctionCallbackInfo<Value>& args) {
 void GetConfigJsonSchema(const FunctionCallbackInfo<Value>& args) {
   Local<Context> context = args.GetIsolate()->GetCurrentContext();
   Local<Value> result;
-  if (!ToV8Value(context, options_parser::GenerateConfigJsonSchema(true))
+  if (!ToV8Value(context, options_parser::GenerateConfigJsonSchema())
            .ToLocal(&result)) {
     return;
   }

src/node_options.h

@@ -427,9 +427,7 @@ MapNamespaceOptionsAssociations();
 std::vector<std::string> MapAvailableNamespaces();
 
 // Builds the `node.config.json` JSON Schema from option metadata.
-// `include_additional_properties = false` drops `additionalProperties: false`
-// for forward-compat with older Node reading newer configs.
-std::string GenerateConfigJsonSchema(bool include_additional_properties);
+std::string GenerateConfigJsonSchema();
 
 // Define all namespace entries
 #define OPTION_NAMESPACE_LIST(V)                                               \

test/parallel/test-config-file.js

@@ -165,7 +165,7 @@ test('should throw at unknown flag', async () => {
     `--experimental-config-file=${fixtures.path('rc/unknown-flag.json')}`,
     '-p', '"Hello, World!"',
   ]);
-  assert.match(result.stderr, /Unknown or not allowed option some-unknown-flag for namespace nodeOptions/);
+  assert.match(result.stderr, /\/nodeOptions additional property not allowed: some-unknown-flag/);
   assert.strictEqual(result.stdout, '');
   assert.strictEqual(result.code, 9);
 });
@@ -176,7 +176,7 @@ test('should throw at flag not available in NODE_OPTIONS', async () => {
     `--experimental-config-file=${fixtures.path('rc/not-node-options-flag.json')}`,
     '-p', '"Hello, World!"',
   ]);
-  assert.match(result.stderr, /Unknown or not allowed option test for namespace nodeOptions/);
+  assert.match(result.stderr, /\/nodeOptions additional property not allowed: test/);
   assert.strictEqual(result.stdout, '');
   assert.strictEqual(result.code, 9);
 });
@@ -210,7 +210,7 @@ test('v8 flag should not be allowed in config file', async () => {
     `--experimental-config-file=${fixtures.path('rc/v8-flag.json')}`,
     '-p', '"Hello, World!"',
   ]);
-  assert.match(result.stderr, /V8 flag --abort-on-uncaught-exception is currently not supported/);
+  assert.match(result.stderr, /\/nodeOptions additional property not allowed: abort-on-uncaught-exception/);
   assert.strictEqual(result.stdout, '');
   assert.strictEqual(result.code, 9);
 });
@@ -268,7 +268,7 @@ test('no op flag should throw', async () => {
     `--experimental-config-file=${fixtures.path('rc/no-op.json')}`,
     '-p', '"Hello, World!"',
   ]);
-  assert.match(result.stderr, /No-op flag --http-parser is currently not supported/);
+  assert.match(result.stderr, /\/nodeOptions additional property not allowed: http-parser/);
   assert.match(result.stderr, /no-op\.json: invalid content/);
   assert.strictEqual(result.stdout, '');
   assert.strictEqual(result.code, 9);
@@ -512,7 +512,7 @@ describe('namespace-scoped options', () => {
       `--experimental-config-file=${fixtures.path('rc/unknown-flag-namespace.json')}`,
       '-p', '"Hello, World!"',
     ]);
-    assert.match(result.stderr, /Unknown or not allowed option unknown-flag for namespace test/);
+    assert.match(result.stderr, /\/test additional property not allowed: unknown-flag/);
     assert.strictEqual(result.stdout, '');
     assert.strictEqual(result.code, 9);
   });
@@ -523,7 +523,7 @@ describe('namespace-scoped options', () => {
       `--experimental-config-file=${fixtures.path('rc/unknown-namespace.json')}`,
       '-p', '"Hello, World!"',
     ]);
-    assert.match(result.stderr, /Unknown namespace an-invalid-namespace/);
+    assert.match(result.stderr, /additional property not allowed: an-invalid-namespace/);
     assert.match(result.stderr, /unknown-namespace\.json: invalid content/);
     assert.strictEqual(result.stdout, '');
     assert.strictEqual(result.code, 9);
@@ -648,7 +648,7 @@ describe('namespace-scoped options', () => {
       `--experimental-config-file=${fixtures.path('rc/deprecated-testrunner-namespace.json')}`,
       '-p', '"Hello, World!"',
     ]);
-    assert.match(result.stderr, /the "testRunner" namespace has been removed\. Use "test" instead\./);
+    assert.match(result.stderr, /additional property not allowed: testRunner\. did you mean "test"\?/);
     assert.strictEqual(result.stdout, '');
     assert.strictEqual(result.code, 9);
   });