rn-update 1.0.0

package/cpp/update_flow_core/update_flow_jni.cpp

@@ -0,0 +1,157 @@
+/**
+ * [INPUT]: 依赖 JNI、patch_core/jni_util、flow_json 与 update_flow_core 的纯决策接口
+ * [OUTPUT]: 对 Android NativeUpdateFlow 暴露请求体构建、端点排序和响应处理的 JSON JNI 入口
+ * [POS]: update_flow_core 的 Android 字符串边界，负责 UTF-8/UTF-16 与 JSON 映射而不承载策略
+ */
+// JNI surface of the update-flow decision layer for the Android orchestrator
+// (NativeCheckOrchestrator.java). Pure string-in/string-out: every payload is
+// JSON, matching the decision layer's own boundary. A null return means
+// "input did not parse" and the caller skips the check round; a C++ exception
+// (bad_alloc/length_error from an oversized body) maps onto that same path —
+// it must never unwind through the JNI boundary.
+#include <jni.h>
+
+#include <cstdint>
+#include <exception>
+#include <limits>
+#include <string>
+#include <vector>
+
+#include "../patch_core/jni_util.h"
+#include "flow_json.h"
+#include "update_flow_core.h"
+
+namespace {
+
+jstring ToJString(JNIEnv* env, const std::string& value) {
+  // flow_json emits standard UTF-8, while NewStringUTF expects JNI's modified
+  // UTF-8 and corrupts supplementary code points. Decode explicitly and pass
+  // UTF-16 code units to NewString. Accept encoded surrogate code points too:
+  // strings originating in Java may have entered through modified UTF-8.
+  std::vector<jchar> utf16;
+  utf16.reserve(value.size());
+  size_t i = 0;
+  while (i < value.size()) {
+    const unsigned char first = static_cast<unsigned char>(value[i]);
+    uint32_t codePoint = 0xfffd;
+    size_t width = 1;
+    if (first < 0x80) {
+      codePoint = first;
+    } else if (first >= 0xc2 && first <= 0xdf && i + 1 < value.size()) {
+      const unsigned char b1 = static_cast<unsigned char>(value[i + 1]);
+      if ((b1 & 0xc0) == 0x80) {
+        codePoint = ((first & 0x1f) << 6) | (b1 & 0x3f);
+        width = 2;
+      }
+    } else if (first == 0xc0 && i + 1 < value.size() &&
+               static_cast<unsigned char>(value[i + 1]) == 0x80) {
+      codePoint = 0;  // modified UTF-8 encoding of U+0000
+      width = 2;
+    } else if (first >= 0xe0 && first <= 0xef && i + 2 < value.size()) {
+      const unsigned char b1 = static_cast<unsigned char>(value[i + 1]);
+      const unsigned char b2 = static_cast<unsigned char>(value[i + 2]);
+      if ((b1 & 0xc0) == 0x80 && (b2 & 0xc0) == 0x80 &&
+          !(first == 0xe0 && b1 < 0xa0)) {
+        codePoint = ((first & 0x0f) << 12) | ((b1 & 0x3f) << 6) |
+                    (b2 & 0x3f);
+        width = 3;
+      }
+    } else if (first >= 0xf0 && first <= 0xf4 && i + 3 < value.size()) {
+      const unsigned char b1 = static_cast<unsigned char>(value[i + 1]);
+      const unsigned char b2 = static_cast<unsigned char>(value[i + 2]);
+      const unsigned char b3 = static_cast<unsigned char>(value[i + 3]);
+      if ((b1 & 0xc0) == 0x80 && (b2 & 0xc0) == 0x80 &&
+          (b3 & 0xc0) == 0x80 && !(first == 0xf0 && b1 < 0x90) &&
+          !(first == 0xf4 && b1 > 0x8f)) {
+        codePoint = ((first & 0x07) << 18) | ((b1 & 0x3f) << 12) |
+                    ((b2 & 0x3f) << 6) | (b3 & 0x3f);
+        width = 4;
+      }
+    }
+    i += width;
+    if (codePoint <= 0xffff) {
+      utf16.push_back(static_cast<jchar>(codePoint));
+    } else {
+      codePoint -= 0x10000;
+      utf16.push_back(static_cast<jchar>(0xd800 + (codePoint >> 10)));
+      utf16.push_back(static_cast<jchar>(0xdc00 + (codePoint & 0x3ff)));
+    }
+  }
+  if (utf16.size() > static_cast<size_t>(std::numeric_limits<jsize>::max())) {
+    return nullptr;
+  }
+  return env->NewString(utf16.empty() ? nullptr : utf16.data(),
+                        static_cast<jsize>(utf16.size()));
+}
+
+}  // namespace
+
+extern "C" JNIEXPORT jstring JNICALL
+Java_cn_reactnative_modules_update_NativeUpdateFlow_buildCheckRequestBody(
+    JNIEnv* env, jclass, jstring inputJson) {
+  try {
+    bool ok = false;
+    flowjson::Value input = flowjson::Parse(
+        pakta::jni_util::JStringToString(env, inputJson), &ok);
+    if (!ok || !input.IsObject()) {
+      return nullptr;
+    }
+    return ToJString(
+        env, flowjson::Stringify(updateflow::BuildCheckRequestBody(input)));
+  } catch (...) {
+    return nullptr;
+  }
+}
+
+extern "C" JNIEXPORT jstring JNICALL
+Java_cn_reactnative_modules_update_NativeUpdateFlow_orderEndpointCandidates(
+    JNIEnv* env, jclass, jstring endpointsJson, jdouble randomSample) {
+  try {
+    bool ok = false;
+    flowjson::Value endpoints = flowjson::Parse(
+        pakta::jni_util::JStringToString(env, endpointsJson), &ok);
+    if (!ok || !endpoints.IsArray()) {
+      return nullptr;
+    }
+    return ToJString(env, flowjson::Stringify(updateflow::OrderEndpointCandidates(
+                              endpoints, randomSample)));
+  } catch (...) {
+    return nullptr;
+  }
+}
+
+extern "C" JNIEXPORT jboolean JNICALL
+Java_cn_reactnative_modules_update_NativeUpdateFlow_isValidCheckResponse(
+    JNIEnv* env, jclass, jstring responseText) {
+  if (responseText == nullptr) {
+    return JNI_FALSE;
+  }
+  try {
+    return updateflow::IsValidCheckResponse(
+               pakta::jni_util::JStringToString(env, responseText))
+               ? JNI_TRUE
+               : JNI_FALSE;
+  } catch (...) {
+    return JNI_FALSE;
+  }
+}
+
+extern "C" JNIEXPORT jstring JNICALL
+Java_cn_reactnative_modules_update_NativeUpdateFlow_handleCheckResponse(
+    JNIEnv* env, jclass, jstring responseText, jstring identityJson,
+    jstring afterDownload) {
+  try {
+    bool ok = false;
+    flowjson::Value identity = flowjson::Parse(
+        pakta::jni_util::JStringToString(env, identityJson), &ok);
+    if (!ok || !identity.IsObject()) {
+      return nullptr;
+    }
+    return ToJString(env, flowjson::Stringify(updateflow::HandleCheckResponse(
+                              pakta::jni_util::JStringToString(env, responseText),
+                              identity, false,
+                              pakta::jni_util::JStringToString(env, afterDownload))));
+  } catch (...) {
+    return nullptr;
+  }
+}

package/expo-module.config.json

@@ -0,0 +1,13 @@
+{
+ "platforms": ["apple", "android"],
+  "apple": {
+    "modules": ["ExpoPaktaModule"],
+    "reactDelegateHandlers": ["ExpoPaktaReactDelegateHandler"],
+    "podspecPath":"rn-update.podspec"
+  },
+  "android": {
+    "modules": [
+      "expo.modules.pakta.ExpoPaktaModule"
+    ]
+  }
+}

package/harmony/hvigor-plugin.ts

@@ -0,0 +1,212 @@
+/**
+ * [INPUT]: 依赖 Node fs/path、包装应用 AppScope/app.json5 与 Hvigor 的当前工作目录
+ * [OUTPUT]: 对外提供 reactNativeUpdatePlugin，在构建前生成 rawfile/meta.json 的 build time 与 versionName，并保留宿主固定 channel
+ * [POS]: Harmony 根构建扩展，把应用身份转成 UpdateContext 可读取的 opaque 构建元信息
+ */
+import fs from 'fs';
+import path from 'path';
+import { randomUUID } from 'crypto';
+
+// Structural view of the hvigor objects this plugin touches, so the file has
+// no compile-time dependency on @ohos/hvigor typings (it is compiled by the
+// consumer's hvigor, whatever version that is).
+interface HvigorTaskContext {
+  getBuildMode?: () => string;
+}
+
+interface HvigorModuleContext {
+  getBuildMode?: () => string;
+}
+
+interface HvigorTask {
+  name: string;
+  run: (taskContext?: HvigorTaskContext) => void;
+  dependencies?: string[];
+  postDependencies?: string[];
+}
+
+interface HvigorNodeLike {
+  getNodePath?: () => string;
+  getParentNode?: () => HvigorNodeLike | undefined;
+  getContext?: (pluginId: string) => HvigorModuleContext | undefined;
+  registerTask?: (task: HvigorTask) => void;
+}
+
+export const META_RELATIVE_PATH = 'src/main/resources/rawfile/meta.json';
+const TASK_NAME = 'paktaWriteBuildMeta';
+// OhosPluginId.OHOS_HAP_PLUGIN / OHOS_HSP_PLUGIN / OHOS_HAR_PLUGIN.
+const MODULE_PLUGIN_IDS = ['ohosHapPlugin', 'ohosHspPlugin', 'ohosHarPlugin'];
+
+function readVersionName(projectDir: string): string {
+  const appJsonPath = path.resolve(projectDir, 'AppScope/app.json5');
+  if (!fs.existsSync(appJsonPath)) {
+    return '';
+  }
+  const content = fs.readFileSync(appJsonPath, 'utf-8');
+  const match = content.match(
+    /(?:"versionName"|versionName):\s*["']([^"']+)["']/,
+  );
+  return match?.[1] || '';
+}
+
+// Only `hvigorw assemble{Hap,App,Hsp,Har}` (DevEco's Build/Run actions pass
+// the same task) should touch the consumer's source tree; IDE sync
+// (`--sync`), `clean` and friends must not rewrite meta.json.
+export function isAssembleInvocation(argv: string[]): boolean {
+  return argv.some(arg => /^assemble/i.test(arg));
+}
+
+export function resolveBuildMode(
+  node: HvigorNodeLike,
+  taskContext: HvigorTaskContext | undefined,
+  argv: string[],
+): string {
+  if (taskContext && typeof taskContext.getBuildMode === 'function') {
+    return String(taskContext.getBuildMode());
+  }
+  if (typeof node.getContext === 'function') {
+    for (const pluginId of MODULE_PLUGIN_IDS) {
+      try {
+        const context = node.getContext(pluginId);
+        if (context && typeof context.getBuildMode === 'function') {
+          return String(context.getBuildMode());
+        }
+      } catch (e) {
+        // not this module type
+      }
+    }
+  }
+  // `hvigorw assembleHap -p buildMode=release` (DevEco passes the same
+  // property for its build actions); hvigor's default mode is debug.
+  const fromArgv = argv.find(arg => arg.startsWith('buildMode='));
+  return fromArgv ? fromArgv.substring('buildMode='.length) : 'debug';
+}
+
+// The plugin is meant for a module hvigorfile (entry/hvigorfile.ts). When it
+// is applied from the project hvigorfile instead, the node path is the
+// project root (AppScope lives there): fall back to entry/ like the original
+// plugin did, so an existing setup keeps working.
+export function resolveModuleDir(node: HvigorNodeLike, cwd: string): string {
+  const nodePath =
+    typeof node.getNodePath === 'function' ? node.getNodePath() : '';
+  if (!nodePath) {
+    return path.resolve(cwd, 'entry');
+  }
+  if (fs.existsSync(path.join(nodePath, 'AppScope', 'app.json5'))) {
+    console.warn(
+      'reactNativeUpdatePlugin: applied at project level; writing meta.json ' +
+        'into entry/. Apply it from the module hvigorfile instead.',
+    );
+    return path.join(nodePath, 'entry');
+  }
+  return nodePath;
+}
+
+export function resolveProjectDir(
+  node: HvigorNodeLike,
+  moduleDir: string,
+): string {
+  const parent =
+    typeof node.getParentNode === 'function' ? node.getParentNode() : undefined;
+  if (parent && typeof parent.getNodePath === 'function') {
+    const parentPath = parent.getNodePath();
+    if (parentPath) {
+      return parentPath;
+    }
+  }
+  return path.dirname(moduleDir);
+}
+
+// Debug builds get "0" like Android's `pakta_build_time` resValue: a debug
+// rebuild must not look like a new binary and reset the update state. Release
+// builds use an opaque UUID; no consumer may infer time or ordering from it.
+export function buildMetaContent(
+  buildMode: string,
+  versionName: string,
+  _now: number,
+  channel = '',
+): { pakta_build_time: string; versionName: string; channel?: string } {
+  const content: {
+    pakta_build_time: string;
+    versionName: string;
+    channel?: string;
+  } = {
+    pakta_build_time:
+      buildMode.toLowerCase() === 'release' ? randomUUID() : '0',
+    versionName,
+  };
+  const normalizedChannel = channel.trim();
+  if (normalizedChannel) {
+    content.channel = normalizedChannel;
+  }
+  return content;
+}
+
+/**
+ * Writes rawfile/meta.json (pakta_build_time + versionName) into the module
+ * this plugin is applied to. The write happens in a build task that runs
+ * before resources are compiled, not in apply(): apply() runs on every hvigor
+ * invocation including IDE sync, and only assemble invocations register the
+ * task at all.
+ */
+export function reactNativeUpdatePlugin() {
+  return {
+    pluginId: 'reactNativeUpdatePlugin',
+    apply(node?: HvigorNodeLike) {
+      const argv = process.argv;
+      if (!isAssembleInvocation(argv)) {
+        return;
+      }
+      const safeNode: HvigorNodeLike = node ?? {};
+      const moduleDir = resolveModuleDir(safeNode, process.cwd());
+      const projectDir = resolveProjectDir(safeNode, moduleDir);
+
+      const writeMeta = (taskContext?: HvigorTaskContext) => {
+        const buildMode = resolveBuildMode(safeNode, taskContext, argv);
+        const metaFilePath = path.resolve(moduleDir, META_RELATIVE_PATH);
+        fs.mkdirSync(path.dirname(metaFilePath), { recursive: true });
+        let channel = '';
+        try {
+          const existing = JSON.parse(fs.readFileSync(metaFilePath, 'utf8')) as {
+            channel?: unknown;
+          };
+          if (typeof existing.channel === 'string') {
+            channel = existing.channel;
+          }
+        } catch {
+          // First build or a hand-written malformed file: the new metadata
+          // remains valid and the host can add channel before packaging.
+        }
+        const metaContent = buildMetaContent(
+          buildMode,
+          readVersionName(projectDir),
+          Date.now(),
+          channel,
+        );
+        fs.writeFileSync(metaFilePath, JSON.stringify(metaContent, null, 2));
+        console.log(`Build time written to ${metaFilePath} (${buildMode})`);
+      };
+
+      if (typeof safeNode.registerTask === 'function') {
+        try {
+          safeNode.registerTask({
+            name: TASK_NAME,
+            run: writeMeta,
+            dependencies: ['default@PreBuild'],
+            postDependencies: ['default@ProcessResource'],
+          });
+          return;
+        } catch (e) {
+          console.warn(
+            `reactNativeUpdatePlugin: task registration failed (${
+              e instanceof Error ? e.message : String(e)
+            }), writing meta.json at apply time`,
+          );
+        }
+      }
+      // Very old hvigor without task registration: keep the previous
+      // behaviour (write at apply time), still only for assemble builds.
+      writeMeta();
+    },
+  };
+}

package/harmony/pakta/src/README.md

@@ -0,0 +1,74 @@
+# rn-update — HarmonyOS module (`pakta`)
+
+Integration notes for the HAR that ships in the `rn-update` npm
+package (`harmony/pakta.har`). The general setup lives in the project README;
+this file covers what the host app must declare itself.
+
+## Permissions
+
+The HAR does not declare `requestPermissions`: downloads and update checks run
+inside the host app's process, so the **host** must request the network
+permission in its entry `module.json5`:
+
+```json5
+{
+  "module": {
+    "requestPermissions": [
+      { "name": "ohos.permission.INTERNET" }
+    ]
+  }
+}
+```
+
+Without it every check and download fails with a network error.
+
+## No https → http downgrade (`cleartextTrafficPermitted`)
+
+`@ohos.net.http` follows redirects internally and exposes neither a switch nor
+the final URL, so unlike Android/iOS the module cannot itself refuse an
+`https → http` redirect. What it does: when the configured endpoints are all
+`https://`, any `http://` endpoint injected through the remote endpoint list
+and any `http://` artifact URL in a check decision are ignored.
+
+To close the redirect gap, keep cleartext traffic disabled for the app in
+`entry/src/main/resources/base/profile/network_config.json` (and reference it
+from `module.json5` via `"metadata": [{ "name": "network_config", "resource": "$profile:network_config" }]`):
+
+```json
+{
+  "network-security-config": {
+    "base-config": {
+      "cleartextTrafficPermitted": false
+    }
+  }
+}
+```
+
+## Build-time metadata (`hvigor-plugin`)
+
+Apply the plugin from the **module** hvigorfile (`entry/hvigorfile.ts`):
+
+```ts
+import { hapTasks } from '@ohos/hvigor-ohos-plugin';
+import { reactNativeUpdatePlugin } from 'pakta/hvigor-plugin';
+
+export default {
+  system: hapTasks,
+  plugins: [reactNativeUpdatePlugin()],
+};
+```
+
+It writes `src/main/resources/rawfile/meta.json` (`pakta_build_time`,
+`versionName`) into that module during `assemble*` builds only, before
+resources are compiled. Debug builds get `pakta_build_time: "0"` like Android,
+so a debug rebuild does not look like a new binary. Add the generated file to
+`.gitignore`.
+
+## Versioning
+
+`oh-package.json5` `version` mirrors the npm package version;
+`scripts/build-harmony-har.js` rewrites it before `assembleHar` and
+`scripts/check-release-version.js` asserts the committed value matches.
+
+This file is packaged with the npm module (`harmony/pakta/src/`) so it is
+available next to the sources in `node_modules/rn-update`.

package/harmony/pakta/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,92 @@
+# [INPUT]: 依赖仓库 cpp/patch_core、cpp/update_flow_core、android/jni 适配、RNOH/ACE NAPI 与可选 staged native 源
+# [OUTPUT]: 构建 rnupdate 共享库及可选 rnoh_pakta TurboModule 库，统一 C++17、头路径、第三方解码器与 Release 裁剪
+# [POS]: Harmony 原生交付入口，负责链接拓扑而不重写共享补丁/状态/更新流算法
+
+cmake_minimum_required(VERSION 3.13)
+project(rnupdate LANGUAGES C CXX)
+
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+set(REPO_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/../../../../../)
+set(STAGED_NATIVE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/android-generated)
+set(ANDROID_JNI_DIR ${REPO_ROOT}/android/jni)
+if(NOT EXISTS ${ANDROID_JNI_DIR}/hpatch.c)
+    set(ANDROID_JNI_DIR ${STAGED_NATIVE_DIR}/jni)
+endif()
+set(PATCH_CORE_DIR ${REPO_ROOT}/cpp/patch_core)
+if(NOT EXISTS ${PATCH_CORE_DIR}/patch_core.cpp)
+    set(PATCH_CORE_DIR ${STAGED_NATIVE_DIR}/patch_core)
+endif()
+set(UPDATE_FLOW_CORE_DIR ${REPO_ROOT}/cpp/update_flow_core)
+if(NOT EXISTS ${UPDATE_FLOW_CORE_DIR}/update_flow_core.cpp)
+    set(UPDATE_FLOW_CORE_DIR ${STAGED_NATIVE_DIR}/update_flow_core)
+endif()
+
+# Always compile from source. A prebuilt-import branch used to live here, but
+# it had no symbol verification: a stale libs/<abi>/librnupdate.so missing a
+# newly added export (e.g. getSupportedDiffVersion) would silently ship and
+# crash getConstants at runtime.
+set(HDIFFPATCH_DIR ${ANDROID_JNI_DIR}/HDiffPatch)
+set(LZMA_DIR ${ANDROID_JNI_DIR}/lzma)
+set(HDP_SOURCES
+     ${CMAKE_CURRENT_SOURCE_DIR}/pakta.cpp
+     ${PATCH_CORE_DIR}/archive_patch_core.cpp
+     ${PATCH_CORE_DIR}/digest.cpp
+     ${PATCH_CORE_DIR}/hbc_transform.cpp
+     ${PATCH_CORE_DIR}/hbc_transform_wire.cpp
+     ${PATCH_CORE_DIR}/patch_core.cpp
+     ${PATCH_CORE_DIR}/state_core.cpp
+     ${UPDATE_FLOW_CORE_DIR}/flow_json.cpp
+     ${UPDATE_FLOW_CORE_DIR}/update_flow_core.cpp
+     ${ANDROID_JNI_DIR}/hpatch.c
+     ${HDIFFPATCH_DIR}/libHDiffPatch/HPatch/patch.c
+     ${HDIFFPATCH_DIR}/file_for_patch.c
+     ${LZMA_DIR}/C/LzmaDec.c
+     ${LZMA_DIR}/C/Lzma2Dec.c
+)
+
+add_library(rnupdate SHARED
+    ${HDP_SOURCES}
+)
+
+target_include_directories(rnupdate PRIVATE
+     ${CMAKE_CURRENT_SOURCE_DIR}
+     ${PATCH_CORE_DIR}
+     ${UPDATE_FLOW_CORE_DIR}
+     ${ANDROID_JNI_DIR}
+     ${HDIFFPATCH_DIR}
+     ${HDIFFPATCH_DIR}/libHDiffPatch/HPatch
+     ${LZMA_DIR}/C
+)
+
+target_link_libraries(rnupdate PUBLIC
+    libace_napi.z.so
+)
+
+if(TARGET rnoh)
+    add_library(rnoh_pakta SHARED
+        ${CMAKE_CURRENT_SOURCE_DIR}/PaktaTurboModule.cpp
+    )
+    target_include_directories(rnoh_pakta PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+    target_link_libraries(rnoh_pakta PUBLIC rnoh)
+endif()
+
+# Optimize binary size for Release builds of the NAPI library. --gc-sections
+# only drops anything when every function/data item sits in its own section,
+# and the module registers itself through NAPI_MODULE's static constructor,
+# so no symbol needs default visibility. Scoped to rnupdate: rnoh_pakta must
+# keep exporting PaktaTurboModule (JSI_EXPORT) for the host's PackageProvider.
+if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+    target_compile_options(rnupdate PRIVATE
+        -ffunction-sections
+        -fdata-sections
+        -fvisibility=hidden
+        -fvisibility-inlines-hidden
+    )
+    # Strip debug symbols and garbage-collect the unused sections.
+    target_link_options(rnupdate PRIVATE -Wl,--gc-sections -s)
+endif()

package/harmony/pakta/src/main/cpp/PaktaPackage.h

@@ -0,0 +1,60 @@
+/**
+ * [INPUT]: 依赖 RNOH Package/TurboModuleFactoryDelegate 与 PaktaTurboModule 声明
+ * [OUTPUT]: 对外提供 PaktaPackage 和 PaktaTurboModuleFactoryDelegate，按模块名创建 Pakta C++ 桥
+ * [POS]: Harmony RNOH 注册边界，只负责模块发现和构造，不承载更新状态或文件 IO
+ */
+/**
+ * MIT License
+ *
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef PAKTA_PACKAGE_H
+#define PAKTA_PACKAGE_H
+
+#include "RNOH/Package.h"
+#include "PaktaTurboModule.h"
+
+using namespace rnoh;
+using namespace facebook;
+
+class PaktaTurboModuleFactoryDelegate : public TurboModuleFactoryDelegate {
+public:
+    SharedTurboModule createTurboModule(Context ctx, const std::string &name) const override
+    {
+        if (name == "Pakta") {
+        return std::make_shared<PaktaTurboModule>(ctx, name);
+        }
+        return nullptr;
+    };
+};
+
+namespace rnoh {
+class PaktaPackage : public Package {
+public:
+    PaktaPackage(Package::Context ctx) : Package(ctx){}
+    std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate() override
+    {
+    return std::make_unique<PaktaTurboModuleFactoryDelegate>();
+    }
+};
+} // namespace rnoh
+#endif