@lynx-js/lynx-library-headers 0.0.1-alpha.4

package/README.md

@@ -0,0 +1,53 @@
+# @lynx-js/lynx-library-headers
+
+Header package for Lynx embedder C/C++ API and weak N-API based native
+libraries. This package only provides headers; it does not scaffold, build, or
+register libraries.
+
+## Usage
+
+Resolve the package root from your build script, then add `include/` to the
+native target include directories:
+
+```js
+const path = require('node:path');
+const headersRoot = path.dirname(
+  require.resolve('@lynx-js/lynx-library-headers/package.json'),
+);
+```
+
+The published package contains:
+
+- Lynx embedder C API headers.
+- Lynx embedder C++ wrapper headers such as `lynx_native_view.h`,
+  `lynx_value.h`, and `lynx_view.h`.
+- Weak N-API headers used by Lynx native modules.
+- Lynx value C API headers required by the embedder C API.
+- `lynx_extension.h` and `lynx/extension.h` convenience wrapper headers.
+- `lynx/registration.h` for generic embedder static registration helpers.
+
+Embedders and Lynxtron packages use static registration from the native library:
+
+```cpp
+#include <lynx/registration.h>
+
+void BindDemoModule(::lynx::registration::LynxNapiEnv env,
+                    ::lynx::registration::LynxNapiValue exports);
+lynx_native_view_t* CreateDemoView(void* opaque);
+
+LYNX_REGISTER_NATIVE_MODULE("DemoModule", BindDemoModule)
+LYNX_REGISTER_ELEMENT(
+    "DemoModule",
+    "x-demo-view",
+    CreateDemoView)
+```
+
+Use `LYNX_REGISTER_NATIVE_MODULE` for Lynx weak N-API native modules and
+`LYNX_REGISTER_ELEMENT` for Lynx native view elements. A library that exposes
+both features should call both macros, keeping the native module and element
+registrations separate.
+
+Lynxtron loads matching native libraries through its autolink flow; loading the
+library is enough for these static registrations to run.
+
+Run `npm run copy-headers` in this package when updating the source headers.

package/include/base/include/value/lynx_api_types.h

@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2017 Node.js API collaborators. All Rights Reserved.
+ *
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file in the root of the source tree.
+ */
+
+// Copyright 2025 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+
+#ifndef BASE_INCLUDE_VALUE_LYNX_API_TYPES_H_
+#define BASE_INCLUDE_VALUE_LYNX_API_TYPES_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifndef LYNX_VALUE_COMPILE_UNIT
+#define LYNX_VALUE_COMPILE_UNIT
+#endif
+
+#define LYNX_VALUE_OPAQUE_STRUCT__2(name, unit) lynx_##name##__##unit
+#define LYNX_VALUE_OPAQUE_STRUCT__1(name, unit) \
+  LYNX_VALUE_OPAQUE_STRUCT__2(name, unit)
+#define LYNX_VALUE_OPAQUE_STRUCT(name) \
+  LYNX_VALUE_OPAQUE_STRUCT__1(name, LYNX_VALUE_COMPILE_UNIT)
+
+typedef struct lynx_value_ptr__* lynx_value_ptr;
+typedef struct lynx_api_env__* lynx_api_env;
+
+typedef struct LYNX_VALUE_OPAQUE_STRUCT(api_context) * lynx_api_context;
+typedef enum {
+  lynx_api_ok,
+  lynx_api_failed,
+  lynx_api_invalid_arg,
+  lynx_api_not_support,
+  lynx_api_bool_expected,
+  lynx_api_double_expected,
+  lynx_api_int32_expected,
+  lynx_api_uint32_expected,
+  lynx_api_int64_expected,
+  lynx_api_uint64_expected,
+  lynx_api_string_expected,
+  lynx_api_array_expected,
+  lynx_api_map_expected,
+  lynx_api_external_expected,
+  lynx_api_arraybuffer_expected,
+  lynx_api_function_expected,
+  lynx_api_index_out_of_range,
+  lynx_api_handle_scope_mismatch,
+} lynx_api_status;
+
+struct lynx_api_env__ {
+  lynx_api_context ctx;
+};
+
+#endif  // BASE_INCLUDE_VALUE_LYNX_API_TYPES_H_

package/include/base/include/value/lynx_value_api.h

@@ -0,0 +1,204 @@
+// Copyright 2025 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+
+#ifndef BASE_INCLUDE_VALUE_LYNX_VALUE_API_H_
+#define BASE_INCLUDE_VALUE_LYNX_VALUE_API_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "base/include/value/lynx_value_types.h"
+
+#ifdef _WIN32
+#ifdef lynx_EXPORTS
+#define LYNX_VALUE_EXPORT __declspec(dllexport)
+#else
+#define LYNX_VALUE_EXPORT __declspec(dllimport)
+#endif  // lynx_EXPORTS
+#elif defined(__ANDROID__)
+#define LYNX_VALUE_EXPORT
+#else
+#define LYNX_VALUE_EXPORT __attribute__((visibility("default")))
+#endif  // _WIN32
+
+// Get the type of lynx_value.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_typeof(lynx_api_env env,
+                                                    lynx_value value,
+                                                    lynx_value_type* result);
+// This API creates a lynx_value of type null.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_create_null(lynx_api_env env,
+                                                         lynx_value* result);
+// This API creates a lynx_value of type bool with given values.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_create_bool(lynx_api_env env,
+                                                         bool value,
+                                                         lynx_value* result);
+// This API creates a lynx_value of type bool with given values.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_create_double(lynx_api_env env,
+                                                           double value,
+                                                           lynx_value* result);
+// This API creates a lynx_value of type int32_t with given values.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_create_int32(lynx_api_env env,
+                                                          int32_t value,
+                                                          lynx_value* result);
+// This API creates a lynx_value of type uint32_t with given values.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_create_uint32(lynx_api_env env,
+                                                           uint32_t value,
+                                                           lynx_value* result);
+// This API creates a lynx_value of type int64_t with given values.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_create_int64(lynx_api_env env,
+                                                          int64_t value,
+                                                          lynx_value* result);
+// This API creates a lynx_value of type uint64_t with given values.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_create_uint64(lynx_api_env env,
+                                                           uint64_t value,
+                                                           lynx_value* result);
+// This API creates a string value from a UTF8-encoded C string. The native
+// string is copied.
+// This API allocates memory on the heap to store the string. After use,
+// lynx_value_remove_reference must be called to free this portion of
+// memory, otherwise it will result in a memory leak.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_create_string_utf8(
+    lynx_api_env env, const char* str, size_t length, lynx_value* result);
+// This API creates a map container.
+// This API allocates memory on the heap to store the container. After use,
+// lynx_value_remove_reference must be called to free this portion of
+// memory, otherwise it will result in a memory leak.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_create_map(lynx_api_env env,
+                                                        lynx_value* result);
+// This API creates a array container.
+// This API allocates memory on the heap to store the container. After use,
+// lynx_value_remove_reference must be called to free this portion of
+// memory, otherwise it will result in a memory leak.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_create_array(lynx_api_env env,
+                                                          lynx_value* result);
+
+// Read the numberic value from lynx_value.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_get_number(lynx_api_env env,
+                                                        lynx_value value,
+                                                        double* result);
+// Read the double value from lynx_value. lynx_api_double_expected is returned
+// if the types do not match.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_get_double(lynx_api_env env,
+                                                        lynx_value value,
+                                                        double* result);
+// Read the int32_t value from lynx_value. lynx_api_int32_expected is returned
+// if the types do not match.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_get_int32(lynx_api_env env,
+                                                       lynx_value value,
+                                                       int32_t* result);
+// Read the uint32_t value from lynx_value. lynx_api_uint32_expected is returned
+// if the types do not match.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_get_uint32(lynx_api_env env,
+                                                        lynx_value value,
+                                                        uint32_t* result);
+// Read the int64_t value from lynx_value. lynx_api_int64_expected is returned
+// if the types do not match.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_get_int64(lynx_api_env env,
+                                                       lynx_value value,
+                                                       int64_t* result);
+// Read the uint64_t value from lynx_value. lynx_api_uint64_expected is returned
+// if the types do not match.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_get_uint64(lynx_api_env env,
+                                                        lynx_value value,
+                                                        uint64_t* result);
+// Read the bool value from lynx_value. lynx_api_bool_expected is returned
+// if the types do not match.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_get_bool(lynx_api_env env,
+                                                      lynx_value value,
+                                                      bool* result);
+// Read the UTF8-encoded string value from lynx_value. lynx_api_string_expected
+// is returned if the types do not match. If the buf argument is passed NULL,
+// the length of the string in bytes and excluding the null terminator is
+// returned in result
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_get_string_utf8(lynx_api_env env,
+                                                             lynx_value value,
+                                                             char* buf,
+                                                             size_t bufsize,
+                                                             size_t* result);
+// Read the length of array from lynx_value. lynx_api_array_expected is returned
+// if the types do not match.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_get_array_length(lynx_api_env env,
+                                                              lynx_value value,
+                                                              uint32_t* result);
+// Insert lynx_value element into array at the index specified.
+// lynx_api_array_expected is returned if the types do not match.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_set_element(lynx_api_env env,
+                                                         lynx_value object,
+                                                         uint32_t index,
+                                                         lynx_value value);
+// Read the array element from lynx_value. lynx_api_array_expected is returned
+// if the types do not match.
+// The reference count of the lynx_value read out is automatically incremented
+// by 1. After use, lynx_value_remove_reference needs to be called to free the
+// memory Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_get_element(lynx_api_env env,
+                                                         lynx_value object,
+                                                         uint32_t index,
+                                                         lynx_value* result);
+// This API checks if the object passed in has the named property.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_has_property(lynx_api_env env,
+                                                          lynx_value object,
+                                                          const char* utf8name,
+                                                          bool* result);
+// Read the map keys from lynx_value. lynx_api_map_expected is returned
+// if the types do not match.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_get_property_names(
+    lynx_api_env env, lynx_value object, lynx_value* result);
+// Set lynx_value property into map at the key specified.
+// lynx_api_map_expected is returned if the types do not match.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status
+lynx_value_set_named_property(lynx_api_env env, lynx_value object,
+                              const char* utf8name, lynx_value value);
+// Read the map property from lynx_value. lynx_api_map_expected is returned
+// if the types do not match.
+// The reference count of the lynx_value read out is automatically incremented
+// by 1. After use, lynx_value_remove_reference needs to be called to free the
+// memory. Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status
+lynx_value_get_named_property(lynx_api_env env, lynx_value object,
+                              const char* utf8name, lynx_value* result);
+// This API is used for iterating through array or map type lynx_value.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_iterate_value(
+    lynx_api_env env, lynx_value object, lynx_value_iterator_callback callback,
+    void* pfunc, void* raw_data);
+// Increment the reference count by 1 for pointer data.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_add_reference(
+    lynx_api_env env, lynx_value value, lynx_value_ref* result);
+// Decrement the reference count by 1 for pointer data.
+// Returns lynx_api_ok if the API succeeded.
+LYNX_VALUE_EXPORT lynx_api_status lynx_value_remove_reference(
+    lynx_api_env env, lynx_value value, lynx_value_ref ref);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // BASE_INCLUDE_VALUE_LYNX_VALUE_API_H_

package/include/base/include/value/lynx_value_types.h

@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) 2017 Node.js API collaborators. All Rights Reserved.
+ *
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file in the root of the source tree.
+ */
+
+// Copyright 2025 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+
+#ifndef BASE_INCLUDE_VALUE_LYNX_VALUE_TYPES_H_
+#define BASE_INCLUDE_VALUE_LYNX_VALUE_TYPES_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "base/include/value/lynx_api_types.h"
+
+typedef struct LYNX_VALUE_OPAQUE_STRUCT(value_ref) * lynx_value_ref;
+
+typedef enum : uint8_t {
+  lynx_value_null,
+  lynx_value_undefined,
+  lynx_value_bool,
+  lynx_value_double,
+  lynx_value_int32,
+  lynx_value_uint32,
+  lynx_value_int64,
+  lynx_value_uint64,
+  lynx_value_nan,
+  lynx_value_string,
+  lynx_value_array,
+  lynx_value_map,
+  lynx_value_arraybuffer,
+  lynx_value_object,
+  lynx_value_function,
+  lynx_value_function_table,
+  lynx_value_external,  // external raw pointer
+  lynx_value_extended,
+} lynx_value_type;
+
+#define LYNX_VALUE_BASE_STORAGE_DEFINITION \
+  union {                                  \
+    bool val_bool;                         \
+    double val_double;                     \
+    int32_t val_int32;                     \
+    uint32_t val_uint32;                   \
+    int64_t val_int64;                     \
+    uint64_t val_uint64;                   \
+    lynx_value_ptr val_ptr;                \
+  };
+
+struct lynx_value {
+  LYNX_VALUE_BASE_STORAGE_DEFINITION
+  lynx_value_type type;
+
+  uint8_t __unnamed0__;
+  uint8_t __unnamed1__;
+  uint8_t __unnamed2__;
+
+  int32_t tag;
+};
+
+static_assert(sizeof(lynx_value) == 16,
+              "The lynx_value was precisely designed to be 16 bytes.");
+
+typedef void (*lynx_value_iterator_callback)(lynx_api_env env, lynx_value key,
+                                             lynx_value val, void* pfunc,
+                                             void* raw_data);
+typedef void (*lynx_value_print_ext_callback)(void* stream, const char* str);
+
+#endif  // BASE_INCLUDE_VALUE_LYNX_VALUE_TYPES_H_

package/include/capi/lynx_env_capi.h

@@ -0,0 +1,47 @@
+// Copyright 2025 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+#ifndef PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_ENV_CAPI_H_
+#define PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_ENV_CAPI_H_
+
+#include "lynx_export.h"
+#include "lynx_extension_module_types_capi.h"
+#include "lynx_native_module_capi.h"
+
+LYNX_EXTERN_C_BEGIN
+
+// Retrieves the SDK version of Lynx sdk.
+LYNX_CAPI_EXPORT const char* lynx_env_get_sdk_version();
+
+// Sets the ICU data path for the LynxEnv.
+LYNX_CAPI_EXPORT void lynx_env_set_icu_data_path(const char* icu_data_path);
+
+// Retrieves the ICU data path for the LynxEnv.
+LYNX_CAPI_EXPORT const char* lynx_env_get_icu_data_path();
+
+// Lynx devtools
+typedef void (*lynx_env_open_card_callback)(void* user_data, const char* url);
+
+LYNX_CAPI_EXPORT void lynx_env_set_devtool_app_info(const char* name,
+                                                    const char* value);
+LYNX_CAPI_EXPORT void lynx_env_enable_devtool(int enable);
+LYNX_CAPI_EXPORT int lynx_env_is_devtool_enabled();
+LYNX_CAPI_EXPORT int lynx_env_connect_devtool(const char* url);
+LYNX_CAPI_EXPORT void lynx_env_set_open_card_callback(
+    lynx_env_open_card_callback callback, void* user_data);
+// logbox
+LYNX_CAPI_EXPORT void lynx_env_enable_logbox(int enable);
+LYNX_CAPI_EXPORT int lynx_env_is_logbox_enabled();
+// Global native module
+LYNX_CAPI_EXPORT void lynx_env_register_native_module(
+    const char* name, napi_module_creator creator, void* opaque);
+// Global extension module
+LYNX_CAPI_EXPORT void lynx_env_register_extension_module(
+    const char* name, extension_module_creator creator, bool is_lazy_create,
+    void* opaque);
+
+LYNX_CAPI_EXPORT void lynx_env_set_node_platform(void* platform);
+
+LYNX_EXTERN_C_END
+
+#endif  // PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_ENV_CAPI_H_

package/include/capi/lynx_event_reporter_service_capi.h

@@ -0,0 +1,67 @@
+// Copyright 2025 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+#ifndef PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_EVENT_REPORTER_SERVICE_CAPI_H_
+#define PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_EVENT_REPORTER_SERVICE_CAPI_H_
+
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "base/include/value/lynx_value_types.h"
+#include "lynx_export.h"
+
+LYNX_EXTERN_C_BEGIN
+
+// Forward declaration of the lynx_event_reporter_service_t struct.
+typedef struct lynx_event_reporter_service_t lynx_event_reporter_service_t;
+
+// Define a function pointer type for event reporter handling.
+typedef void (*lynx_event_report_func)(lynx_event_reporter_service_t*,
+                                       const char* event_name,
+                                       const lynx_value& params);
+
+// Define a function pointer type for performance event reporter handling.
+typedef void (*lynx_performance_event_report_func)(
+    lynx_event_reporter_service_t*, const lynx_value& params);
+
+// Creates a new event reporter service instance.
+LYNX_CAPI_EXPORT lynx_event_reporter_service_t*
+lynx_event_reporter_service_create(void* user_data);
+
+// Create a new event reporter service instance with a finalizer.
+// The finalizer will be called when the service is released.
+// The instance's lifecycle is based on reference count.
+LYNX_CAPI_EXPORT lynx_event_reporter_service_t*
+lynx_event_reporter_service_create_with_finalizer(
+    void* user_data, void (*finalizer)(lynx_event_reporter_service_t*, void*));
+
+// Binds a report function to the event reporter service.
+LYNX_CAPI_EXPORT void lynx_event_reporter_service_bind(
+    lynx_event_reporter_service_t*, lynx_event_report_func f);
+
+// Binds a performance report function to the event reporter service.
+LYNX_CAPI_EXPORT void lynx_event_reporter_service_bind_performance_report_func(
+    lynx_event_reporter_service_t*, lynx_performance_event_report_func f);
+
+// Retrieves the user data associated with the event reporter service.
+LYNX_CAPI_EXPORT void* lynx_event_reporter_service_get_user_data(
+    lynx_event_reporter_service_t* event_report_service);
+
+// Releases the resources associated with the event reporter service.
+LYNX_CAPI_EXPORT void lynx_event_reporter_service_release(
+    lynx_event_reporter_service_t*);
+
+// Call the event reporter handler associated with the event reporter service.
+LYNX_CAPI_EXPORT void lynx_event_reporter_service_on_event(
+    lynx_event_reporter_service_t* event_report_service, const char* event_name,
+    const lynx_value& params);
+
+// Call the event reporter handler associated with the performance event
+// reporter service.
+LYNX_CAPI_EXPORT void lynx_event_reporter_service_on_performance_event(
+    lynx_event_reporter_service_t* event_report_service,
+    const lynx_value& params);
+
+LYNX_EXTERN_C_END
+
+#endif  // PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_EVENT_REPORTER_SERVICE_CAPI_H_

package/include/capi/lynx_export.h

@@ -0,0 +1,27 @@
+// Copyright 2025 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+#ifndef PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_EXPORT_H_
+#define PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_EXPORT_H_
+
+#ifdef _WIN32
+#ifndef lynx_EXPORTS
+#define LYNX_CAPI_EXPORT __declspec(dllimport)
+#else
+#define LYNX_CAPI_EXPORT __declspec(dllexport)
+#endif
+#else
+#define LYNX_CAPI_EXPORT __attribute__((visibility("default")))
+#endif
+
+#ifdef __cplusplus
+#define LYNX_EXTERN_C extern "C"
+#define LYNX_EXTERN_C_BEGIN LYNX_EXTERN_C {
+#define LYNX_EXTERN_C_END }
+#else
+#define LYNX_EXTERN_C
+#define LYNX_EXTERN_C_BEGIN
+#define LYNX_EXTERN_C_END
+#endif
+
+#endif  // PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_EXPORT_H_