@chilkat/react-native 11.6.1

package/cpp/HybridZipEntry.cpp

@@ -0,0 +1,395 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridZipEntry.hpp"
+#include "HybridBinData.hpp"
+#include "HybridCkDateTime.hpp"
+#include "HybridStream.hpp"
+#include "HybridStringBuilder.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridZipEntry::HybridZipEntry()
+    : HybridObject(HybridZipEntrySpec::TAG), ChilkatObject<CkZipEntry>("ZipEntry", CkZipEntry::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridZipEntry::HybridZipEntry(CkZipEntry* owned)
+    : HybridObject(HybridZipEntrySpec::TAG), ChilkatObject<CkZipEntry>("ZipEntry", owned) {
+  init();
+}
+
+void HybridZipEntry::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridZipEntry::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridZipEntry::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridZipEntry::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridZipEntry::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridZipEntry::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridZipEntry::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridZipEntry::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridZipEntry::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridZipEntry::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridZipEntry::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridZipEntry::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridZipEntry::getComment() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Comment(_s);
+  return rt::stdString(_s);
+}
+void HybridZipEntry::setComment(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "comment");
+  this->ck().put_Comment(value.c_str());
+}
+double HybridZipEntry::getCompressedLength() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_CompressedLength());
+}
+double HybridZipEntry::getCompressedLength64() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_CompressedLength64());
+}
+std::string HybridZipEntry::getCompressedLengthStr() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_CompressedLengthStr(_s);
+  return rt::stdString(_s);
+}
+double HybridZipEntry::getCompressionLevel() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_CompressionLevel());
+}
+void HybridZipEntry::setCompressionLevel(double value) {
+  this->beginCall();
+  this->ck().put_CompressionLevel(rt::toInt(value, "compressionLevel"));
+}
+double HybridZipEntry::getCompressionMethod() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_CompressionMethod());
+}
+void HybridZipEntry::setCompressionMethod(double value) {
+  this->beginCall();
+  this->ck().put_CompressionMethod(rt::toInt(value, "compressionMethod"));
+}
+double HybridZipEntry::getCrc() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Crc());
+}
+double HybridZipEntry::getEntryID() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_EntryID());
+}
+double HybridZipEntry::getEntryType() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_EntryType());
+}
+std::string HybridZipEntry::getFileDateTimeStr() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_FileDateTimeStr(_s);
+  return rt::stdString(_s);
+}
+void HybridZipEntry::setFileDateTimeStr(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "fileDateTimeStr");
+  this->ck().put_FileDateTimeStr(value.c_str());
+}
+std::string HybridZipEntry::getFileName() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_FileName(_s);
+  return rt::stdString(_s);
+}
+void HybridZipEntry::setFileName(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "fileName");
+  this->ck().put_FileName(value.c_str());
+}
+std::string HybridZipEntry::getFileNameHex() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_FileNameHex(_s);
+  return rt::stdString(_s);
+}
+double HybridZipEntry::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridZipEntry::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+bool HybridZipEntry::getIsDirectory() {
+  this->beginCall();
+  return this->ck().get_IsDirectory();
+}
+bool HybridZipEntry::getTextFlag() {
+  this->beginCall();
+  return this->ck().get_TextFlag();
+}
+void HybridZipEntry::setTextFlag(bool value) {
+  this->beginCall();
+  this->ck().put_TextFlag(value);
+}
+double HybridZipEntry::getUncompressedLength() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_UncompressedLength());
+}
+double HybridZipEntry::getUncompressedLength64() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_UncompressedLength64());
+}
+std::string HybridZipEntry::getUncompressedLengthStr() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncompressedLengthStr(_s);
+  return rt::stdString(_s);
+}
+bool HybridZipEntry::getIsAesEncrypted() {
+  this->beginCall();
+  return this->ck().get_IsAesEncrypted();
+}
+double HybridZipEntry::getEncryptionKeyLen() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_EncryptionKeyLen());
+}
+
+// ---- Methods ----
+
+void HybridZipEntry::appendString(const std::string& strContent, const std::string& charset) {
+  this->beginCall();
+  appendString_impl(strContent, charset);
+}
+void HybridZipEntry::appendString_impl(const std::string& strContent, const std::string& charset) {
+  rt::checkNoNul(strContent, "strContent");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().AppendString(strContent.c_str(), charset.c_str())) throw this->fail("appendString");
+}
+std::shared_ptr<Promise<void>> HybridZipEntry::appendStringAsync(const std::string& strContent, const std::string& charset) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridZipEntry>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("ZipEntry.appendStringAsync", std::move(_parts), [_self, strContent, charset]() {
+    _self->appendString_impl(strContent, charset);
+  });
+}
+
+std::string HybridZipEntry::copyToBase64() {
+  this->beginCall();
+  return copyToBase64_impl();
+}
+std::string HybridZipEntry::copyToBase64_impl() {
+  CkString _out;
+  if (!this->ck().CopyToBase64(_out)) throw this->fail("copyToBase64");
+  return rt::stdString(_out);
+}
+
+std::string HybridZipEntry::copyToHex() {
+  this->beginCall();
+  return copyToHex_impl();
+}
+std::string HybridZipEntry::copyToHex_impl() {
+  CkString _out;
+  if (!this->ck().CopyToHex(_out)) throw this->fail("copyToHex");
+  return rt::stdString(_out);
+}
+
+void HybridZipEntry::extract(const std::string& dirPath) {
+  this->beginCall();
+  extract_impl(dirPath);
+}
+void HybridZipEntry::extract_impl(const std::string& dirPath) {
+  rt::checkNoNul(dirPath, "dirPath");
+  if (!this->ck().Extract(dirPath.c_str())) throw this->fail("extract");
+}
+std::shared_ptr<Promise<void>> HybridZipEntry::extractAsync(const std::string& dirPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridZipEntry>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("ZipEntry.extractAsync", std::move(_parts), [_self, dirPath]() {
+    _self->extract_impl(dirPath);
+  });
+}
+
+void HybridZipEntry::extractInto(const std::string& dirPath) {
+  this->beginCall();
+  extractInto_impl(dirPath);
+}
+void HybridZipEntry::extractInto_impl(const std::string& dirPath) {
+  rt::checkNoNul(dirPath, "dirPath");
+  if (!this->ck().ExtractInto(dirPath.c_str())) throw this->fail("extractInto");
+}
+std::shared_ptr<Promise<void>> HybridZipEntry::extractIntoAsync(const std::string& dirPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridZipEntry>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("ZipEntry.extractIntoAsync", std::move(_parts), [_self, dirPath]() {
+    _self->extractInto_impl(dirPath);
+  });
+}
+
+void HybridZipEntry::replaceString(const std::string& strContent, const std::string& charset) {
+  this->beginCall();
+  replaceString_impl(strContent, charset);
+}
+void HybridZipEntry::replaceString_impl(const std::string& strContent, const std::string& charset) {
+  rt::checkNoNul(strContent, "strContent");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().ReplaceString(strContent.c_str(), charset.c_str())) throw this->fail("replaceString");
+}
+
+void HybridZipEntry::setDt(const std::shared_ptr<HybridCkDateTimeSpec>& dt) {
+  this->beginCall();
+  setDt_impl(dt);
+}
+void HybridZipEntry::setDt_impl(const std::shared_ptr<HybridCkDateTimeSpec>& dt) {
+  this->ck().SetDt(rt::implOf<HybridCkDateTime>(dt, "dt").ck());
+}
+
+std::string HybridZipEntry::unzipToString(double lineEndingBehavior, const std::string& srcCharset) {
+  this->beginCall();
+  return unzipToString_impl(lineEndingBehavior, srcCharset);
+}
+std::string HybridZipEntry::unzipToString_impl(double lineEndingBehavior, const std::string& srcCharset) {
+  rt::checkNoNul(srcCharset, "srcCharset");
+  CkString _out;
+  if (!this->ck().UnzipToString(rt::toInt(lineEndingBehavior, "lineEndingBehavior"), srcCharset.c_str(), _out)) throw this->fail("unzipToString");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridZipEntry::unzipToStringAsync(double lineEndingBehavior, const std::string& srcCharset) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridZipEntry>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("ZipEntry.unzipToStringAsync", std::move(_parts), [_self, lineEndingBehavior, srcCharset]() {
+    return _self->unzipToString_impl(lineEndingBehavior, srcCharset);
+  });
+}
+
+void HybridZipEntry::unzipToStream(const std::shared_ptr<HybridStreamSpec>& toStream) {
+  this->beginCall();
+  unzipToStream_impl(toStream);
+}
+void HybridZipEntry::unzipToStream_impl(const std::shared_ptr<HybridStreamSpec>& toStream) {
+  if (!this->ck().UnzipToStream(rt::implOf<HybridStream>(toStream, "toStream").ck())) throw this->fail("unzipToStream");
+}
+std::shared_ptr<Promise<void>> HybridZipEntry::unzipToStreamAsync(const std::shared_ptr<HybridStreamSpec>& toStream) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridZipEntry>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(toStream);
+  return rt::runAsync<void>("ZipEntry.unzipToStreamAsync", std::move(_parts), [_self, toStream]() {
+    _self->unzipToStream_impl(toStream);
+  });
+}
+
+void HybridZipEntry::unzipToBd(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  unzipToBd_impl(binData);
+}
+void HybridZipEntry::unzipToBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  if (!this->ck().UnzipToBd(rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("unzipToBd");
+}
+std::shared_ptr<Promise<void>> HybridZipEntry::unzipToBdAsync(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridZipEntry>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(binData);
+  return rt::runAsync<void>("ZipEntry.unzipToBdAsync", std::move(_parts), [_self, binData]() {
+    _self->unzipToBd_impl(binData);
+  });
+}
+
+void HybridZipEntry::unzipToSb(double lineEndingBehavior, const std::string& srcCharset, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  unzipToSb_impl(lineEndingBehavior, srcCharset, sb);
+}
+void HybridZipEntry::unzipToSb_impl(double lineEndingBehavior, const std::string& srcCharset, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  rt::checkNoNul(srcCharset, "srcCharset");
+  if (!this->ck().UnzipToSb(rt::toInt(lineEndingBehavior, "lineEndingBehavior"), srcCharset.c_str(), rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("unzipToSb");
+}
+std::shared_ptr<Promise<void>> HybridZipEntry::unzipToSbAsync(double lineEndingBehavior, const std::string& srcCharset, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridZipEntry>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(sb);
+  return rt::runAsync<void>("ZipEntry.unzipToSbAsync", std::move(_parts), [_self, lineEndingBehavior, srcCharset, sb]() {
+    _self->unzipToSb_impl(lineEndingBehavior, srcCharset, sb);
+  });
+}
+
+void HybridZipEntry::getNextMatch(const std::string& pattern) {
+  this->beginCall();
+  getNextMatch_impl(pattern);
+}
+void HybridZipEntry::getNextMatch_impl(const std::string& pattern) {
+  rt::checkNoNul(pattern, "pattern");
+  if (!this->ck().GetNextMatch(pattern.c_str())) throw this->fail("getNextMatch");
+}
+
+void HybridZipEntry::getNext() {
+  this->beginCall();
+  getNext_impl();
+}
+void HybridZipEntry::getNext_impl() {
+  if (!this->ck().GetNext()) throw this->fail("getNext");
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridZipEntry::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridZipEntry::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridZipEntry::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridZipEntry::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridZipEntry::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridZipEntry.hpp

@@ -0,0 +1,102 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// ZipEntry: the Nitro HybridObject over Chilkat's CkZipEntry (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridZipEntrySpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkZipEntry.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridZipEntry final : public HybridZipEntrySpec, public ChilkatObject<CkZipEntry> {
+public:
+  HybridZipEntry();                                  // `new ZipEntry()` from JS
+  explicit HybridZipEntry(CkZipEntry* owned);  // wraps an object a Chilkat method returned
+  void dispose() override;
+
+  // ---- Properties ----
+  std::string getLastErrorHtml() override;
+  std::string getLastErrorText() override;
+  std::string getLastErrorXml() override;
+  std::string getVersion() override;
+  std::string getDebugLogFilePath() override;
+  void setDebugLogFilePath(const std::string& value) override;
+  bool getVerboseLogging() override;
+  void setVerboseLogging(bool value) override;
+  bool getLastMethodSuccess() override;
+  void setLastMethodSuccess(bool value) override;
+  std::string getComment() override;
+  void setComment(const std::string& value) override;
+  double getCompressedLength() override;
+  double getCompressedLength64() override;
+  std::string getCompressedLengthStr() override;
+  double getCompressionLevel() override;
+  void setCompressionLevel(double value) override;
+  double getCompressionMethod() override;
+  void setCompressionMethod(double value) override;
+  double getCrc() override;
+  double getEntryID() override;
+  double getEntryType() override;
+  std::string getFileDateTimeStr() override;
+  void setFileDateTimeStr(const std::string& value) override;
+  std::string getFileName() override;
+  void setFileName(const std::string& value) override;
+  std::string getFileNameHex() override;
+  double getHeartbeatMs() override;
+  void setHeartbeatMs(double value) override;
+  bool getIsDirectory() override;
+  bool getTextFlag() override;
+  void setTextFlag(bool value) override;
+  double getUncompressedLength() override;
+  double getUncompressedLength64() override;
+  std::string getUncompressedLengthStr() override;
+  bool getIsAesEncrypted() override;
+  double getEncryptionKeyLen() override;
+
+  // ---- Methods ----
+  void appendString(const std::string& strContent, const std::string& charset) override;
+  std::shared_ptr<Promise<void>> appendStringAsync(const std::string& strContent, const std::string& charset) override;
+  std::string copyToBase64() override;
+  std::string copyToHex() override;
+  void extract(const std::string& dirPath) override;
+  std::shared_ptr<Promise<void>> extractAsync(const std::string& dirPath) override;
+  void extractInto(const std::string& dirPath) override;
+  std::shared_ptr<Promise<void>> extractIntoAsync(const std::string& dirPath) override;
+  void replaceString(const std::string& strContent, const std::string& charset) override;
+  void setDt(const std::shared_ptr<HybridCkDateTimeSpec>& dt) override;
+  std::string unzipToString(double lineEndingBehavior, const std::string& srcCharset) override;
+  std::shared_ptr<Promise<std::string>> unzipToStringAsync(double lineEndingBehavior, const std::string& srcCharset) override;
+  void unzipToStream(const std::shared_ptr<HybridStreamSpec>& toStream) override;
+  std::shared_ptr<Promise<void>> unzipToStreamAsync(const std::shared_ptr<HybridStreamSpec>& toStream) override;
+  void unzipToBd(const std::shared_ptr<HybridBinDataSpec>& binData) override;
+  std::shared_ptr<Promise<void>> unzipToBdAsync(const std::shared_ptr<HybridBinDataSpec>& binData) override;
+  void unzipToSb(double lineEndingBehavior, const std::string& srcCharset, const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  std::shared_ptr<Promise<void>> unzipToSbAsync(double lineEndingBehavior, const std::string& srcCharset, const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void getNextMatch(const std::string& pattern) override;
+  void getNext() override;
+
+  // ---- Events (ReactNativeGen_DESIGN.md §6) ----
+  std::optional<std::function<void(double)>> getOnPercentDone() override;
+  void setOnPercentDone(const std::optional<std::function<void(double)>>& cb) override;
+  std::optional<std::function<void(const std::string&, const std::string&)>> getOnProgressInfo() override;
+  void setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) override;
+  void abort() override;
+
+private:
+  void init();
+  void appendString_impl(const std::string& strContent, const std::string& charset);
+  std::string copyToBase64_impl();
+  std::string copyToHex_impl();
+  void extract_impl(const std::string& dirPath);
+  void extractInto_impl(const std::string& dirPath);
+  void replaceString_impl(const std::string& strContent, const std::string& charset);
+  void setDt_impl(const std::shared_ptr<HybridCkDateTimeSpec>& dt);
+  std::string unzipToString_impl(double lineEndingBehavior, const std::string& srcCharset);
+  void unzipToStream_impl(const std::shared_ptr<HybridStreamSpec>& toStream);
+  void unzipToBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData);
+  void unzipToSb_impl(double lineEndingBehavior, const std::string& srcCharset, const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void getNextMatch_impl(const std::string& pattern);
+  void getNext_impl();
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/runtime/AsyncCall.hpp

@@ -0,0 +1,96 @@
+// AsyncCall.hpp -- hand-maintained (not generated).
+// runAsync(): the machinery behind every Promise-returning xxxAsync twin
+// (ReactNativeGen_DESIGN.md §5).
+//
+//  1. Marks the receiver and every HybridObject argument busy; if any already is, throws
+//     synchronously (Nitro turns that into a JS exception at the call site).
+//  2. Creates the Promise and starts one dedicated, detached std::thread that runs the body,
+//     then resolves or rejects -- Nitro delivers either on the JS thread.  Nitro's shared
+//     thread pool is deliberately not used: an SFTP transfer can hold a thread for minutes.
+//  3. Clears the busy marks in every case.  The lambda owns shared_ptrs to all participants,
+//     so garbage collection cannot free them mid-call.
+//
+// The body receives no JS memory: strings and buffers were copied by the generated twin on
+// the JS thread before calling runAsync (Bytes.hpp).
+#pragma once
+
+#include "ChilkatObject.hpp"
+#include <NitroModules/HybridObject.hpp>
+#include <NitroModules/Promise.hpp>
+#include <exception>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <type_traits>
+#include <vector>
+
+namespace margelo::nitro::chilkat {
+namespace rt {
+
+namespace detail {
+
+// Marks all participants busy or none; returns false (marking nothing) when one is busy.
+inline const char* markAllBusy(const std::vector<std::shared_ptr<HybridObject>>& participants, const char* what) {
+  std::vector<ChilkatBusy*> marked;
+  for (const auto& p : participants) {
+    ChilkatBusy* b = dynamic_cast<ChilkatBusy*>(p.get());
+    if (!b) continue;   // not one of ours; nothing to guard
+    if (!b->markBusy(what)) {
+      const char* other = b->busyWith();
+      for (ChilkatBusy* m : marked) m->clearBusy();
+      return other ? other : "another call";
+    }
+    marked.push_back(b);
+  }
+  return nullptr;
+}
+
+inline void clearAllBusy(const std::vector<std::shared_ptr<HybridObject>>& participants) {
+  for (const auto& p : participants) {
+    ChilkatBusy* b = dynamic_cast<ChilkatBusy*>(p.get());
+    if (b) b->clearBusy();
+  }
+}
+
+inline std::exception_ptr prefixed(const std::string& what, const char* twinName) {
+  return std::make_exception_ptr(std::runtime_error(std::string(twinName) + ": " + what));
+}
+
+} // namespace detail
+
+// T is the twin's result type (void for status methods).  `self` must be participants[0].
+// `twinName` is the fully qualified JS name ("Http.quickGetStrAsync"), used in the busy
+// message and as the rejection prefix.
+template <typename T, typename Fn>
+std::shared_ptr<Promise<T>> runAsync(const char* twinName, std::vector<std::shared_ptr<HybridObject>> participants, Fn body) {
+  if (const char* other = detail::markAllBusy(participants, twinName)) {
+    ChilkatBusy* self = dynamic_cast<ChilkatBusy*>(participants.front().get());
+    std::string cls = self ? self->chilkatClassName() : "object";
+    throw std::runtime_error(cls + " is busy (" + other + " in progress)");
+  }
+  auto promise = Promise<T>::create();
+  std::thread([twinName, participants = std::move(participants), body = std::move(body), promise]() mutable {
+    try {
+      if constexpr (std::is_void_v<T>) {
+        body();
+        detail::clearAllBusy(participants);
+        promise->resolve();
+      } else {
+        T result = body();
+        detail::clearAllBusy(participants);
+        promise->resolve(std::move(result));
+      }
+    } catch (const std::exception& e) {
+      detail::clearAllBusy(participants);
+      promise->reject(detail::prefixed(e.what(), twinName));
+    } catch (...) {
+      detail::clearAllBusy(participants);
+      promise->reject(detail::prefixed("unknown native error", twinName));
+    }
+  }).detach();
+  return promise;
+}
+
+} // namespace rt
+} // namespace margelo::nitro::chilkat

package/cpp/runtime/Bytes.hpp

@@ -0,0 +1,49 @@
+// Bytes.hpp -- hand-maintained (not generated).
+// ArrayBuffer <-> Chilkat byte conversions (ReactNativeGen_DESIGN.md §3.2).
+//
+// A JS-created ArrayBuffer is non-owning: its memory belongs to the JS VM and may only be
+// read synchronously on the JS thread.  So the generated public members read `data()` and
+// `size()` right away, and an xxxAsync twin copies the bytes (copyBytes) on the JS thread
+// before its worker starts.  Returned buffers are owning copies (ArrayBuffer::copy), safe to
+// hand to JS from any thread.
+#pragma once
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <vector>
+
+namespace margelo::nitro::chilkat {
+namespace rt {
+
+// A pointer/length view of a buffer argument, valid only for the current synchronous call.
+struct ByteView {
+  const uint8_t* data;
+  size_t size;
+};
+
+inline ByteView viewOf(const std::shared_ptr<ArrayBuffer>& buf) {
+  if (!buf || buf->size() == 0) return ByteView{nullptr, 0};
+  return ByteView{buf->data(), buf->size()};
+}
+
+// An owning copy, for the async twins.
+inline std::vector<uint8_t> copyBytes(const std::shared_ptr<ArrayBuffer>& buf) {
+  ByteView v = viewOf(buf);
+  if (v.size == 0 || v.data == nullptr) return std::vector<uint8_t>();
+  return std::vector<uint8_t>(v.data, v.data + v.size);
+}
+
+inline ByteView viewOf(const std::vector<uint8_t>& v) {
+  return ByteView{v.empty() ? nullptr : v.data(), v.size()};
+}
+
+// Chilkat bytes -> a new owning ArrayBuffer (empty buffer for no data).
+inline std::shared_ptr<ArrayBuffer> toArrayBuffer(const void* data, size_t size) {
+  if (data == nullptr || size == 0) return ArrayBuffer::allocate(0);
+  return ArrayBuffer::copy(static_cast<const uint8_t*>(data), size);
+}
+
+} // namespace rt
+} // namespace margelo::nitro::chilkat