react-native-update 10.59.1 → 10.60.0

package/cpp/patch_core/patch_core.cpp

@@ -21,7 +21,10 @@
 #include "hbc_transform_wire.h"
 
 extern "C" {
-#include "hpatch.h"
+// Relative to this file: under use_frameworks! a bare "hpatch.h" resolves
+// to the flattened framework PrivateHeaders copy, whose own HDiffPatch/
+// includes then fail.
+#include "../hpatch/hpatch.h"
 }
 
 namespace pushy {
@@ -487,14 +490,6 @@ Status MergeDirectoryRecursively(
 
 }  // namespace
 
-Status Status::Ok() {
-  return Status{true, std::string()};
-}
-
-Status Status::Error(const std::string& message) {
-  return Status{false, message};
-}
-
 Status ValidateManifest(const PatchManifest& manifest) {
   return ValidateManifestImpl(manifest);
 }
@@ -580,7 +575,7 @@ Status ApplyBundlePatchWithHbcTransform(
     const FileSourcePatchOptions& options,
     const BundleRebuilder& bundle_patcher) {
   hbc::HbcTransformMeta meta;
-  if (!hbc::ParseHbcTransformMeta(options.bundle_hbc_transform_meta, &meta)) {
+  if (!hbc::ParseHbcTransformMeta(options.manifest.bundle_hbc_transform_meta, &meta)) {
     return Status::Error("Invalid hbcTransform metadata");
   }
   if (meta.v != hbc::kHbcTransformSupportedVersion) {
@@ -654,7 +649,7 @@ Status ApplyPatchFromFileSource(
   }
 
   Status bundle_status =
-      options.bundle_hbc_transform_meta.empty()
+      options.manifest.bundle_hbc_transform_meta.empty()
           ? bundle_patcher.Apply(
                 options.origin_bundle_path,
                 options.bundle_patch_path,
@@ -727,11 +722,16 @@ Status CleanupOldEntries(
       max_age_days, now);
 }
 
-Status CleanupOldEntries(
+namespace {
+
+// Lists the non-dot entries of root_dir that are not kept and are at least
+// max_age_days old: the one selection rule shared by delete and trash.
+Status SelectOldEntries(
     const std::string& root_dir,
     const std::vector<std::string>& keep_names,
     int max_age_days,
-    std::time_t now) {
+    std::time_t now,
+    std::vector<std::string>* out) {
   DIR* dir = opendir(root_dir.c_str());
   if (!dir) {
     if (errno == ENOENT) {
@@ -765,15 +765,61 @@ Status CleanupOldEntries(
     if (effective_now - st.st_mtime < max_age_seconds) {
       continue;
     }
+    out->push_back(name);
+  }
 
-    Status remove_status = RemovePathRecursively(entry_path);
+  closedir(dir);
+  return Status::Ok();
+}
+
+}  // namespace
+
+Status CleanupOldEntries(
+    const std::string& root_dir,
+    const std::vector<std::string>& keep_names,
+    int max_age_days,
+    std::time_t now) {
+  std::vector<std::string> doomed;
+  Status select_status =
+      SelectOldEntries(root_dir, keep_names, max_age_days, now, &doomed);
+  if (!select_status) {
+    return select_status;
+  }
+  for (const std::string& name : doomed) {
+    Status remove_status = RemovePathRecursively(JoinPath(root_dir, name));
     if (!remove_status) {
-      closedir(dir);
       return remove_status;
     }
   }
+  return Status::Ok();
+}
 
-  closedir(dir);
+Status MoveOldEntriesToTrash(
+    const std::string& root_dir,
+    const std::vector<std::string>& keep_names,
+    int max_age_days,
+    const std::string& trash_dir,
+    std::time_t now) {
+  std::vector<std::string> doomed;
+  Status select_status =
+      SelectOldEntries(root_dir, keep_names, max_age_days, now, &doomed);
+  if (!select_status || doomed.empty()) {
+    return select_status;
+  }
+  Status dir_status = EnsureDirectory(trash_dir);
+  if (!dir_status) {
+    return dir_status;
+  }
+  for (const std::string& name : doomed) {
+    std::string target = JoinPath(trash_dir, name);
+    for (int suffix = 1; PathExists(target); ++suffix) {
+      target = JoinPath(trash_dir, name + "." + IntToString(suffix));
+    }
+    const std::string source = JoinPath(root_dir, name);
+    if (rename(source.c_str(), target.c_str()) != 0) {
+      return MakeErrnoStatus("Failed to move " + source + " to trash");
+    }
+  }
   return Status::Ok();
 }
 

package/cpp/patch_core/patch_core.h

@@ -17,8 +17,12 @@ struct Status {
 
   explicit operator bool() const { return ok; }
 
-  static Status Ok();
-  static Status Error(const std::string& message);
+  // Inline so a core that only reports a Status (install_record.cpp) links
+  // without patch_core.cpp and its hpatch dependencies.
+  static Status Ok() { return Status{true, std::string()}; }
+  static Status Error(const std::string& message) {
+    return Status{false, message};
+  }
 };
 
 struct CopyOperation {
@@ -33,9 +37,16 @@ struct CopyOperation {
   uint32_t expected_crc = 0;
 };
 
+// What a patch archive's __diff.json declares (ParsePatchManifest in
+// patch_manifest.h is the one parser every platform uses).
 struct PatchManifest {
   std::vector<CopyOperation> copies;
   std::vector<std::string> deletes;
+  // __diff.json 中该 bundle patch 条目的 hbcTransform 元数据(JSON 文本)。
+  // 非空时 patch 走变换域:T(origin) → hpatch → T⁻¹。元数据不可解析或
+  // 变换规范版本不受支持时返回错误(调用方回退整包),绝不忽略元数据
+  // 直接应用——那会产出损坏的 bundle。
+  std::string bundle_hbc_transform_meta;
 };
 
 struct FileSourcePatchOptions {
@@ -47,11 +58,6 @@ struct FileSourcePatchOptions {
   std::string bundle_output_path;
   std::string merge_source_subdir;
   bool enable_merge = true;
-  // __diff.json 中该 bundle patch 条目的 hbcTransform 元数据(原始 JSON)。
-  // 非空时 patch 走变换域:T(origin) → hpatch → T⁻¹。元数据不可解析或
-  // 变换规范版本不受支持时返回错误(调用方回退整包),绝不忽略元数据
-  // 直接应用——那会产出损坏的 bundle。
-  std::string bundle_hbc_transform_meta;
 };
 
 class BundleRebuilder {
@@ -89,6 +95,20 @@ Status CleanupOldEntries(
     int max_age_days,
     std::time_t now = 0);
 
+// Same selection as CleanupOldEntries, but each doomed entry is renamed into
+// trash_dir (created if needed; must be on the same file system, e.g. a
+// dot-named child of root_dir so the selection itself skips it) instead of
+// being deleted. Renames are cheap, so a caller can hold its version-files
+// lock across this call and delete trash_dir's contents after releasing it
+// (CleanupOldEntries(trash_dir, {}, 0)). A name already present in trash_dir
+// (left over by an interrupted earlier delete) gets a numeric suffix.
+Status MoveOldEntriesToTrash(
+    const std::string& root_dir,
+    const std::vector<std::string>& keep_names,
+    int max_age_days,
+    const std::string& trash_dir,
+    std::time_t now = 0);
+
 bool IsSafeRelativePath(const std::string& path);
 
 namespace internal {

package/cpp/patch_core/patch_manifest.cpp

@@ -0,0 +1,201 @@
+#include "patch_manifest.h"
+
+#include <cmath>
+#include <cstdint>
+#include <unordered_map>
+#include <utility>
+
+// Relative like every other cross-core include (see patch_core.cpp's hpatch.h
+// include): use_frameworks! flattens the pod's headers.
+#include "../update_flow_core/flow_json.h"
+
+namespace pushy {
+namespace delta {
+namespace {
+
+constexpr const char* kErrorPrefix = "delta manifest: ";
+
+Status ManifestError(const std::string& message) {
+  return Status::Error(kErrorPrefix + message);
+}
+
+// null counts as absent everywhere (JSON writers emit it for empty maps).
+bool IsAbsent(const flowjson::Value& value) {
+  return value.IsUndefined() ||
+         value.kind() == flowjson::Value::Kind::Null;
+}
+
+// An integer in [0, 2^32): the only CRC value a client can compare.
+bool ReadCrc32(const flowjson::Value& value, uint32_t* out) {
+  if (!value.IsNumber()) {
+    return false;
+  }
+  const double number = value.AsNumber();
+  if (!std::isfinite(number) || number < 0 || number > 4294967295.0 ||
+      std::floor(number) != number) {
+    return false;
+  }
+  *out = static_cast<uint32_t>(number);
+  return true;
+}
+
+Status ParseCopies(
+    const flowjson::Value& copies,
+    const flowjson::Value& copies_crc,
+    const PatchManifestOptions& options,
+    PatchManifest* manifest) {
+  if (IsAbsent(copies)) {
+    return Status::Ok();
+  }
+  if (!copies.IsObject()) {
+    return ManifestError("copies is not an object");
+  }
+  if (!IsAbsent(copies_crc) && !copies_crc.IsObject()) {
+    return ManifestError("copiesCrc is not an object");
+  }
+  // Target -> declared CRC value; one pass, not a member scan per copy.
+  std::unordered_map<std::string, const flowjson::Value*> crc_by_target;
+  if (copies_crc.IsObject()) {
+    crc_by_target.reserve(copies_crc.members().size());
+    for (const auto& member : copies_crc.members()) {
+      crc_by_target.emplace(member.first, &member.second);
+    }
+  }
+  const std::string& prefix = options.copy_source_prefix;
+  // Source -> the CRC some copy of it declared, to catch contradictions.
+  std::unordered_map<std::string, uint32_t> crc_by_source;
+  manifest->copies.reserve(copies.members().size());
+  for (const auto& member : copies.members()) {
+    const std::string& to = member.first;
+    const flowjson::Value& from_value = member.second;
+    std::string from;
+    if (from_value.IsString()) {
+      from = from_value.AsString();
+    } else if (!IsAbsent(from_value)) {
+      return ManifestError("copies entry is not a string: " + to);
+    }
+    if (!prefix.empty() && from.compare(0, prefix.size(), prefix) == 0) {
+      from.erase(0, prefix.size());
+    }
+    if (from.empty()) {
+      from = to;
+    }
+
+    CopyOperation copy;
+    copy.from = std::move(from);
+    copy.to = to;
+    const auto declared = crc_by_target.find(to);
+    if (declared != crc_by_target.end()) {
+      const flowjson::Value& crc = *declared->second;
+      if (!IsAbsent(crc)) {
+        if (!ReadCrc32(crc, &copy.expected_crc)) {
+          return ManifestError("copiesCrc entry is not a CRC32: " + to);
+        }
+        copy.has_expected_crc = true;
+        const auto inserted =
+            crc_by_source.emplace(copy.from, copy.expected_crc);
+        if (!inserted.second &&
+            inserted.first->second != copy.expected_crc) {
+          return ManifestError("conflicting copiesCrc for source " + copy.from);
+        }
+      }
+    }
+    manifest->copies.push_back(std::move(copy));
+  }
+  return Status::Ok();
+}
+
+Status ParseDeletes(const flowjson::Value& deletes, PatchManifest* manifest) {
+  if (IsAbsent(deletes)) {
+    return Status::Ok();
+  }
+  if (deletes.IsObject()) {
+    manifest->deletes.reserve(deletes.members().size());
+    for (const auto& member : deletes.members()) {
+      manifest->deletes.push_back(member.first);
+    }
+    return Status::Ok();
+  }
+  if (deletes.IsArray()) {
+    manifest->deletes.reserve(deletes.Size());
+    for (const flowjson::Value& path : deletes.elements()) {
+      if (!path.IsString()) {
+        return ManifestError("deletes entry is not a string");
+      }
+      manifest->deletes.push_back(path.AsString());
+    }
+    return Status::Ok();
+  }
+  return ManifestError("deletes is not an object or array");
+}
+
+Status ParseHbcTransform(
+    const flowjson::Value& hbc_transform,
+    const PatchManifestOptions& options,
+    PatchManifest* manifest) {
+  if (IsAbsent(hbc_transform)) {
+    return Status::Ok();
+  }
+  if (!hbc_transform.IsObject()) {
+    return ManifestError("hbcTransform is not an object");
+  }
+  const flowjson::Value& meta =
+      hbc_transform.Get(options.bundle_patch_entry_name);
+  if (IsAbsent(meta)) {
+    return Status::Ok();
+  }
+  if (!meta.IsObject()) {
+    return ManifestError(
+        "hbcTransform entry is not an object: " +
+        options.bundle_patch_entry_name);
+  }
+  manifest->bundle_hbc_transform_meta = flowjson::Stringify(meta);
+  return Status::Ok();
+}
+
+}  // namespace
+
+Status ParsePatchManifest(
+    const std::string& json_text,
+    const PatchManifestOptions& options,
+    PatchManifest* out) {
+  if (out == nullptr) {
+    return Status::Error("Manifest output is required");
+  }
+  flowjson::ParseLimits limits;
+  limits.max_input_bytes =
+      static_cast<size_t>(archive_limits::kMaxManifestBytes);
+  limits.max_nodes = kMaxManifestNodes;
+  bool ok = false;
+  const flowjson::Value root = flowjson::Parse(json_text, limits, &ok);
+  if (!ok) {
+    return ManifestError("invalid JSON or over the size limits");
+  }
+  if (!root.IsObject()) {
+    return ManifestError("not a JSON object");
+  }
+
+  PatchManifest manifest;
+  Status status =
+      ParseCopies(root.Get("copies"), root.Get("copiesCrc"), options, &manifest);
+  if (!status) {
+    return status;
+  }
+  status = ParseDeletes(root.Get("deletes"), &manifest);
+  if (!status) {
+    return status;
+  }
+  status = ParseHbcTransform(root.Get("hbcTransform"), options, &manifest);
+  if (!status) {
+    return status;
+  }
+  status = ValidateManifest(manifest);
+  if (!status) {
+    return status;
+  }
+  *out = std::move(manifest);
+  return Status::Ok();
+}
+
+}  // namespace delta
+}  // namespace pushy

package/cpp/patch_core/patch_manifest.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <cstddef>
+#include <string>
+
+#include "archive_limits.h"
+#include "patch_core.h"
+
+// Keep the core internal to whichever binary links it (see podspec Core).
+#pragma GCC visibility push(hidden)
+
+namespace pushy {
+namespace delta {
+
+// __diff.json, the manifest inside every patch archive, as the generators
+// emit it (pushy-go internal/taskexecutor/bundle_diff.go and
+// react-native-update-cli src/diff.ts):
+//
+//   {"copies":       {"<to>": "<from>" | "", ...},
+//    "copiesCrc":    {"<to>": <crc32>, ...},          package diffs only
+//    "deletes":      {"<path>": 1, ...},              ppk diffs only
+//    "hbcTransform": {"<bundle patch entry>": {...}}} hdiffv2 track only
+//
+// The one parser of that file on Android, iOS and HarmonyOS. The rules are
+// the most permissive form that is still safe; anything else fails the
+// patch, and the JS strategy chain falls back to the full package:
+//  - the text is a JSON object (at most archive_limits::kMaxManifestBytes,
+//    at most kMaxManifestNodes values); unknown members are ignored, and a
+//    member that is null counts as absent;
+//  - copies: an object of target -> source strings. An empty (or null)
+//    source means "same path as the target". Order follows the document;
+//  - copiesCrc: an object keyed by copy *target* (not source). Each value is
+//    an integer in [0, 2^32) or null; any other value is an error (a CRC the
+//    client cannot honour must not silently skip the content check). Keys
+//    naming no copy are ignored. Two copies of one source that declare
+//    different CRCs are a self-contradictory manifest and an error;
+//  - deletes: an object (its keys) or an array of strings;
+//  - hbcTransform: an object; its member named after the bundle patch entry,
+//    when present, must be an object and is handed on re-serialized
+//    (PatchManifest::bundle_hbc_transform_meta). Non-object metadata is an
+//    error, never ignored: applying a transform-domain patch without the
+//    transform produces a corrupt bundle;
+//  - every path passes ValidateManifest.
+// Values of the wrong type (a numeric source, a non-string delete, copies as
+// an array, ...) are errors on every platform.
+struct PatchManifestOptions {
+  // The archive entry whose hbcTransform metadata is extracted
+  // (archive_patch::DefaultBundleDeltaEntryName() unless the platform names
+  // its bundle differently, e.g. HarmonyOS).
+  std::string bundle_patch_entry_name;
+  // Stripped once from the start of every copy source that begins with it,
+  // before the empty-source rule applies. HarmonyOS package diffs name the
+  // origin entries by their HAP path ("resources/rawfile/assets/a.png"),
+  // which the resource manager reads back as "assets/a.png".
+  std::string copy_source_prefix;
+};
+
+// A package holds at most archive_limits::kMaxEntries entries, and the
+// generators emit at most one copy source, one CRC and one delete per entry
+// (plus a few hundred values of hbcTransform metadata). The cap bounds the
+// parsed tree of a hostile 16 MB manifest to about ten MB of heap.
+constexpr size_t kMaxManifestNodes =
+    4 * static_cast<size_t>(archive_limits::kMaxEntries);
+
+// Fails without touching *out.
+Status ParsePatchManifest(
+    const std::string& json_text,
+    const PatchManifestOptions& options,
+    PatchManifest* out);
+
+}  // namespace delta
+}  // namespace pushy
+
+#pragma GCC visibility pop

package/cpp/patch_core/state_ops.h

@@ -1,9 +1,9 @@
 #pragma once
 
 // Single source of truth for the state-machine operation codes shared across
-// the platform glue layers (Android JNI in update_core_android.cpp and
-// HarmonyOS NAPI in pushy.cpp). The integer values MUST stay in sync with the
-// callers on each platform:
+// the platform glue layers (Android JNI in
+// cpp/android_jni/update_core_android.cpp and HarmonyOS NAPI in pushy.cpp).
+// The integer values MUST stay in sync with the callers on each platform:
 //   - Android:  UpdateContext.java (STATE_OP_* constants)
 //   - HarmonyOS: UpdateContext.ts  (StateOperation usage)
 // Do not renumber existing entries; only append new ones.

package/cpp/update_flow_core/flow_json.cpp

@@ -3,6 +3,7 @@
 #include <cmath>
 #include <cstdint>
 #include <cstdio>
+#include <unordered_map>
 
 namespace flowjson {
 
@@ -86,6 +87,40 @@ bool Value::StrictEquals(const Value& a, const Value& b) {
   return false;
 }
 
+bool Value::DeepEquals(const Value& a, const Value& b) {
+  if (a.kind_ == Kind::Array && b.kind_ == Kind::Array) {
+    if (a.elements_.size() != b.elements_.size()) {
+      return false;
+    }
+    for (size_t i = 0; i < a.elements_.size(); i++) {
+      if (!DeepEquals(a.elements_[i], b.elements_[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (a.kind_ == Kind::Object && b.kind_ == Kind::Object) {
+    size_t defined = 0;
+    for (const auto& member : a.members_) {
+      if (member.second.IsUndefined()) {
+        continue;
+      }
+      defined++;
+      const Value& other = b.Get(member.first);
+      if (other.IsUndefined() || !DeepEquals(member.second, other)) {
+        return false;
+      }
+    }
+    for (const auto& member : b.members_) {
+      if (!member.second.IsUndefined()) {
+        defined--;
+      }
+    }
+    return defined == 0;
+  }
+  return StrictEquals(a, b);
+}
+
 namespace {
 
 void AppendEscaped(const std::string& s, std::string* out) {
@@ -232,6 +267,8 @@ namespace {
 // stack limit (size and node count are capped in flow_json.h). Real
 // responses nest ~4 levels.
 constexpr int kMaxDepth = 64;
+// Objects with more members than this get a hash index while parsing.
+constexpr size_t kIndexedObjectMembers = 16;
 
 // Locale-independent decimal -> double. strtod() honours LC_NUMERIC, so a
 // host process that called setlocale() into a comma-decimal locale would stop
@@ -327,7 +364,8 @@ double DecimalToDouble(const std::string& token) {
 
 class Parser {
  public:
-  Parser(const std::string& text) : text_(text) {}
+  Parser(const std::string& text, size_t max_nodes)
+      : text_(text), max_nodes_(max_nodes) {}
 
   Value Run(bool* ok) {
     Value v = ParseValue();
@@ -376,7 +414,7 @@ class Parser {
       ok_ = false;
       return Value::Undefined();
     }
-    if (++nodes_ > kMaxNodes) {
+    if (++nodes_ > max_nodes_) {
       ok_ = false;
       return Value::Undefined();
     }
@@ -409,20 +447,51 @@ class Parser {
     }
   }
 
+  // Duplicate keys keep the first position and the last value (Value::Set
+  // semantics). Large objects (a patch manifest's copies map has thousands
+  // of members) look keys up through a hash index instead of Set's linear
+  // scan, which would make parsing quadratic in the member count.
   Value ParseObject() {
-    Value obj = Value::Object();
     Consume('{');
     SkipWs();
     if (pos_ < text_.size() && text_[pos_] == '}') {
       pos_++;
-      return obj;
+      return Value::Object();
     }
+    Members members;
+    std::unordered_map<std::string, size_t> index;
     while (ok_) {
       SkipWs();
       std::string key = ParseString();
       SkipWs();
       Consume(':');
-      obj.Set(key, ParseValue());
+      Value value = ParseValue();
+      if (members.size() == kIndexedObjectMembers && index.empty()) {
+        for (size_t i = 0; i < members.size(); i++) {
+          index.emplace(members[i].first, i);
+        }
+      }
+      size_t existing = members.size();
+      if (index.empty()) {
+        for (size_t i = 0; i < members.size(); i++) {
+          if (members[i].first == key) {
+            existing = i;
+            break;
+          }
+        }
+      } else {
+        auto found = index.find(key);
+        if (found != index.end()) {
+          existing = found->second;
+        } else {
+          index.emplace(key, members.size());
+        }
+      }
+      if (existing < members.size()) {
+        members[existing].second = std::move(value);
+      } else {
+        members.emplace_back(std::move(key), std::move(value));
+      }
       SkipWs();
       if (pos_ < text_.size() && text_[pos_] == ',') {
         pos_++;
@@ -431,7 +500,7 @@ class Parser {
       Consume('}');
       break;
     }
-    return obj;
+    return Value::Object(std::move(members));
   }
 
   Value ParseArray() {
@@ -635,6 +704,7 @@ class Parser {
   }
 
   const std::string& text_;
+  const size_t max_nodes_;
   size_t pos_ = 0;
   int depth_ = 0;
   size_t nodes_ = 0;
@@ -644,11 +714,15 @@ class Parser {
 }  // namespace
 
 Value Parse(const std::string& text, bool* ok) {
-  if (text.size() > kMaxInputBytes) {
+  return Parse(text, ParseLimits(), ok);
+}
+
+Value Parse(const std::string& text, const ParseLimits& limits, bool* ok) {
+  if (text.size() > limits.max_input_bytes) {
     *ok = false;
     return Value::Undefined();
   }
-  Parser parser(text);
+  Parser parser(text, limits.max_nodes);
   return parser.Run(ok);
 }
 

package/cpp/update_flow_core/flow_json.h

@@ -51,6 +51,12 @@ class Value {
   }
   static Value Array() { return Value(Kind::Array); }
   static Value Object() { return Value(Kind::Object); }
+  // The members must have distinct keys (Set's invariant).
+  static Value Object(Members members) {
+    Value v(Kind::Object);
+    v.members_ = std::move(members);
+    return v;
+  }
 
   Kind kind() const { return kind_; }
   bool IsUndefined() const { return kind_ == Kind::Undefined; }
@@ -81,6 +87,12 @@ class Value {
 
   static bool StrictEquals(const Value& a, const Value& b);
 
+  // Structural equality of JSON values (src/updateFlowCore.ts
+  // jsonDeepEqual): object key order is ignored and undefined members count
+  // as absent; arrays compare element-wise in order; primitives use ===
+  // (so 1 equals 1.0, false is not 0, null equals only null).
+  static bool DeepEquals(const Value& a, const Value& b);
+
  private:
   explicit Value(Kind kind) : kind_(kind) {}
 
@@ -116,6 +128,15 @@ constexpr size_t kMaxNodes = 65536;
 // Lone surrogate escapes decode to U+FFFD so the output is always valid UTF-8.
 Value Parse(const std::string& text, bool* ok);
 
+// Same parser under caller-chosen caps, for documents whose size is bounded
+// by something other than a checkUpdate response (the patch core's
+// __diff.json manifest, cpp/patch_core/patch_manifest.h).
+struct ParseLimits {
+  size_t max_input_bytes = kMaxInputBytes;
+  size_t max_nodes = kMaxNodes;
+};
+Value Parse(const std::string& text, const ParseLimits& limits, bool* ok);
+
 }  // namespace flowjson
 
 #pragma GCC visibility pop