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

package/include/capi/lynx_extension_module_capi.h

@@ -0,0 +1,148 @@
+// 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_EXTENSION_MODULE_CAPI_H_
+#define PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_EXTENSION_MODULE_CAPI_H_
+
+#include <stdint.h>
+
+#include "lynx_export.h"
+#include "lynx_extension_module_types_capi.h"
+#include "lynx_generic_resource_fetcher_capi.h"
+#include "lynx_native_module_capi.h"
+#include "lynx_view_capi.h"
+#include "third_party/weak-node-api/headers/node_api.h"
+#ifdef USE_WEAK_SUFFIX_NAPI
+#include "third_party/weak-node-api/headers/weak_napi_defines.h"
+#endif
+
+LYNX_EXTERN_C_BEGIN
+
+typedef struct lynx_vsync_observer_t lynx_vsync_observer_t;
+
+typedef void (*vsync_observer_callback)(void* user_data, int64_t, int64_t);
+
+// To synchronize with a given VSync, a callback is set, which is called back
+// when the next VSync signal arrives. This callback will be called before any
+// normal callback.
+LYNX_CAPI_EXPORT void lynx_vsync_observer_request_before_animation_frame(
+    lynx_vsync_observer_t*, uintptr_t id, vsync_observer_callback callback,
+    void* user_data);
+// To synchronize with a given VSync, a callback is set, which is normal
+// callback and is called back when the next VSync signal arrives.
+LYNX_CAPI_EXPORT void lynx_vsync_observer_request_animation_frame(
+    lynx_vsync_observer_t*, uintptr_t id, vsync_observer_callback callback,
+    void* user_data);
+// To synchronize with a given VSync, a callback is set, which is called back
+// when the next VSync signal arrives. This callback will be called after any
+// normal callback.
+LYNX_CAPI_EXPORT void
+lynx_vsync_observer_register_after_animation_frame_listener(
+    lynx_vsync_observer_t*, vsync_observer_callback callback, void* user_data);
+
+typedef void (*lynx_extension_module_on_lynx_view_create_func)(
+    lynx_extension_module_t*, lynx_view_t*);
+typedef void (*lynx_extension_module_on_lynx_view_destroy_func)(
+    lynx_extension_module_t*);
+typedef void (*lynx_extension_module_on_runtime_init_func)(
+    lynx_extension_module_t*);
+typedef void (*lynx_extension_module_on_runtime_attach_func)(
+    lynx_extension_module_t*, napi_env, lynx_vsync_observer_t*);
+typedef void (*lynx_extension_module_on_runtime_ready_func)(
+    lynx_extension_module_t*, napi_env, napi_value, const char* url);
+typedef void (*lynx_extension_module_on_runtime_detach_func)(
+    lynx_extension_module_t*);
+typedef void (*lynx_extension_module_on_enter_foreground_func)(
+    lynx_extension_module_t*);
+typedef void (*lynx_extension_module_on_enter_background_func)(
+    lynx_extension_module_t*);
+typedef void (*lynx_extension_module_on_destroy_func)(lynx_extension_module_t*);
+typedef void (*lynx_extension_module_post_task_func)(void* user_data);
+
+// Creates a lynx_extension_module_t instance. It associates the provided
+// user data with the module, which can be retrieved later using
+// `lynx_extension_module_get_user_data`.
+LYNX_CAPI_EXPORT lynx_extension_module_t* lynx_extension_module_create(
+    void* user_data);
+
+// Creates a lynx_extension_module_t instance with a finalizer. It associates
+// the provided user data with the module, which can be retrieved later using
+// `lynx_extension_module_get_user_data`. The finalizer function will be called
+// when the module is released.
+LYNX_CAPI_EXPORT lynx_extension_module_t*
+lynx_extension_module_create_with_finalizer(
+    void* user_data, void (*finalizer)(lynx_extension_module_t*, void*));
+
+LYNX_CAPI_EXPORT void* lynx_extension_module_get_user_data(
+    lynx_extension_module_t*);
+// Binds a lynx_view_create state function to lynx_extension_module_t. This
+// function will be invoked on lynx_view_t create. It is always called on the
+// main thread.
+LYNX_CAPI_EXPORT void lynx_extension_module_bind_lynx_view_create(
+    lynx_extension_module_t*,
+    lynx_extension_module_on_lynx_view_create_func func);
+// Binds a lynx_view_destroy state function to lynx_extension_module_t. This
+// function will be invoked on lynx_view_t destroy. It is always called on the
+// main thread.
+LYNX_CAPI_EXPORT void lynx_extension_module_bind_lynx_view_destroy(
+    lynx_extension_module_t*,
+    lynx_extension_module_on_lynx_view_destroy_func func);
+// Binds a runtime_init state function to lynx_extension_module_t. This
+// function will be invoked on runtime init. It is always called on the main
+// thread.
+LYNX_CAPI_EXPORT void lynx_extension_module_bind_runtime_init(
+    lynx_extension_module_t*, lynx_extension_module_on_runtime_init_func func);
+// Binds a runtime_attach state function to lynx_extension_module_t. This
+// function will be invoked on runtime attached. It is always called on the BTS
+// thread.
+LYNX_CAPI_EXPORT void lynx_extension_module_bind_runtime_attach(
+    lynx_extension_module_t*,
+    lynx_extension_module_on_runtime_attach_func func);
+// Binds a runtime_ready state function to lynx_extension_module_t. This
+// function will be invoked on runtime ready. It is always called on the BTS
+// thread.
+LYNX_CAPI_EXPORT void lynx_extension_module_bind_runtime_ready(
+    lynx_extension_module_t*, lynx_extension_module_on_runtime_ready_func func);
+// Binds a runtime_detach state function to lynx_extension_module_t. This
+// function will be invoked on runtime detached. It is always called on the BTS
+// thread.
+LYNX_CAPI_EXPORT void lynx_extension_module_bind_runtime_detach(
+    lynx_extension_module_t*,
+    lynx_extension_module_on_runtime_detach_func func);
+// Binds application did enter foreground state function to
+// lynx_extension_module_t.
+LYNX_CAPI_EXPORT void lynx_extension_module_bind_enter_foreground(
+    lynx_extension_module_t*,
+    lynx_extension_module_on_enter_foreground_func func);
+// Binds application did enter background state function to
+// lynx_extension_module_t.
+LYNX_CAPI_EXPORT void lynx_extension_module_bind_enter_background(
+    lynx_extension_module_t*,
+    lynx_extension_module_on_enter_background_func func);
+// Binds on lynx_extension_module_t instance destroy state. It will be called
+// before the lynx_extension_module_t is released.
+LYNX_CAPI_EXPORT void lynx_extension_module_bind_on_destroy(
+    lynx_extension_module_t*, lynx_extension_module_on_destroy_func func);
+// Set a napi_module_creator into lynx_extension_module_t. napi_module_creator
+// can be used to create modules that bind napi exports.
+LYNX_CAPI_EXPORT void lynx_extension_module_set_napi_module_creator(
+    lynx_extension_module_t*, napi_module_creator creator);
+// Post task to Runtime thread.
+LYNX_CAPI_EXPORT void lynx_extension_module_post_task_to_runtime(
+    lynx_extension_module_t*, lynx_extension_module_post_task_func func,
+    void* user_data);
+// Is running tasks on current thread.
+LYNX_CAPI_EXPORT bool lynx_extension_module_is_running_on_bts_thread(
+    lynx_extension_module_t*);
+
+LYNX_CAPI_EXPORT void lynx_extension_module_ref(lynx_extension_module_t*);
+LYNX_CAPI_EXPORT void lynx_extension_module_unref(lynx_extension_module_t*);
+
+LYNX_EXTERN_C_END
+
+#ifdef USE_WEAK_SUFFIX_NAPI
+#include "third_party/weak-node-api/headers/weak_napi_undefs.h"
+#endif
+
+#endif  // PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_EXTENSION_MODULE_CAPI_H_

package/include/capi/lynx_extension_module_types_capi.h

@@ -0,0 +1,17 @@
+// 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_EXTENSION_MODULE_TYPES_CAPI_H_
+#define PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_EXTENSION_MODULE_TYPES_CAPI_H_
+
+#include "lynx_export.h"
+
+LYNX_EXTERN_C_BEGIN
+
+typedef struct lynx_extension_module_t lynx_extension_module_t;
+
+typedef lynx_extension_module_t* (*extension_module_creator)(void* opaque);
+
+LYNX_EXTERN_C_END
+
+#endif  // PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_EXTENSION_MODULE_TYPES_CAPI_H_

package/include/capi/lynx_generic_resource_fetcher_capi.h

@@ -0,0 +1,124 @@
+// 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_GENERIC_RESOURCE_FETCHER_CAPI_H_
+#define PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_GENERIC_RESOURCE_FETCHER_CAPI_H_
+
+#include "lynx_export.h"
+#include "lynx_resource_request_capi.h"
+#include "lynx_resource_response_capi.h"
+
+LYNX_EXTERN_C_BEGIN
+
+typedef struct lynx_generic_resource_fetcher_t lynx_generic_resource_fetcher_t;
+
+// Function pointer type for the resource fetching callback. This type defines a
+// callback function used to fetch resources. The callback takes a pointer to a
+// generic resource fetcher, a resource request, and a resource response object.
+// It is responsible for populating the response based on the request.
+typedef void (*fetch_resource_func)(lynx_generic_resource_fetcher_t*,
+                                    lynx_resource_request_t* request,
+                                    lynx_resource_response_t* response);
+
+// Function pointer type for the resource fetch cancellation callback. This type
+// defines a callback function used to cancel an ongoing resource fetch request.
+// The callback takes a pointer to a generic resource fetcher and the unique
+// identifier of the resource request to be cancelled.
+typedef void (*cancel_fetch_func)(lynx_generic_resource_fetcher_t*,
+                                  lynx_resource_request_id request_id);
+
+// Function pointer type for the URL interception callback. This type defines a
+// callback function used to intercept and potentially redirect a resource URL
+// before it is fetched. The callback receives the original URL and returns a
+// new URL. The caller is responsible for freeing the returned string using
+// `free()`.
+typedef char* (*lynx_resource_intercept_func)(const char* url,
+                                              bool should_decode,
+                                              void* user_data);
+
+// Creates a new generic resource fetcher instance. This function allocates and
+// initializes a new generic resource fetcher object. It associates the provided
+// user data with the fetcher, which can be retrieved later using
+// `lynx_generic_resource_fetcher_get_user_data`.
+LYNX_CAPI_EXPORT lynx_generic_resource_fetcher_t*
+lynx_generic_resource_fetcher_create(void* user_data);
+
+// Creates a new generic resource fetcher instance with a finalizer. This
+// function allocates and initializes a new generic resource fetcher object. It
+// associates the provided user data with the fetcher and sets a finalizer
+// function that will be called when the fetcher is released.
+LYNX_CAPI_EXPORT lynx_generic_resource_fetcher_t*
+lynx_generic_resource_fetcher_create_with_finalizer(
+    void* user_data,
+    void (*finalizer)(lynx_generic_resource_fetcher_t*, void*));
+
+LYNX_CAPI_EXPORT void* lynx_generic_resource_fetcher_get_user_data(
+    lynx_generic_resource_fetcher_t*);
+
+// Binds a resource fetching callback to a generic resource fetcher. This
+// function sets the resource fetching callback function for the given generic
+// resource fetcher instance. The callback will be invoked when a resource needs
+// to be fetched.
+LYNX_CAPI_EXPORT void lynx_generic_resource_fetcher_bind_fetch_resource(
+    lynx_generic_resource_fetcher_t*, fetch_resource_func f);
+
+// Binds a resource path fetching callback to a generic resource fetcher. This
+// function sets the resource path fetching callback function for the given
+// generic resource fetcher instance. The callback will be invoked when the path
+// of a resource needs to be fetched.
+LYNX_CAPI_EXPORT void lynx_generic_resource_fetcher_bind_fetch_resource_path(
+    lynx_generic_resource_fetcher_t*, fetch_resource_func f);
+
+// Binds a resource fetch cancellation callback to a generic resource fetcher.
+// This function sets the resource fetch cancellation callback function for the
+// given generic resource fetcher instance. The callback will be invoked when a
+// resource fetch request needs to be cancelled.
+LYNX_CAPI_EXPORT void lynx_generic_resource_fetcher_bind_cancel_fetch(
+    lynx_generic_resource_fetcher_t*, cancel_fetch_func f);
+
+// Binds a URL interception callback to a generic resource fetcher. This
+// function sets the URL interception callback for the given fetcher instance.
+// The callback will be invoked to transform a URL before a resource request is
+// made, using the generic `user_data` provided during the fetcher's creation.
+LYNX_CAPI_EXPORT void lynx_generic_resource_fetcher_bind_intercept_func(
+    lynx_generic_resource_fetcher_t* fetcher,
+    lynx_resource_intercept_func func);
+
+// Releases a generic resource fetcher instance. This function deallocates the
+// memory used by the given generic resource fetcher instance and calls the
+// finalizer function if one was set during creation. After calling this
+// function, the provided pointer becomes invalid.
+LYNX_CAPI_EXPORT void lynx_generic_resource_fetcher_release(
+    lynx_generic_resource_fetcher_t*);
+
+// -----------------------------------------------------------------------------
+// The following functions are provided for an ExtensionModule to invoke the
+// corresponding resource fetching capabilities of the host environment.
+// -----------------------------------------------------------------------------
+
+// Invokes the fetch resource function bound to the generic resource fetcher.
+LYNX_CAPI_EXPORT void lynx_generic_resource_fetcher_fetch_resource(
+    lynx_generic_resource_fetcher_t*, lynx_resource_request_t*,
+    lynx_resource_response_t*);
+
+// Invokes the fetch resource path function bound to the generic resource
+// fetcher.
+LYNX_CAPI_EXPORT void lynx_generic_resource_fetcher_fetch_resource_path(
+    lynx_generic_resource_fetcher_t*, lynx_resource_request_t*,
+    lynx_resource_response_t*);
+
+// Invokes the cancel fetch function bound to the generic resource fetcher.
+LYNX_CAPI_EXPORT void lynx_generic_resource_fetcher_cancel_fetch(
+    lynx_generic_resource_fetcher_t*, lynx_resource_request_id);
+
+// Invokes the intercept function bound to the generic resource fetcher.
+// The caller is responsible for freeing the returned string using
+// `lynx_free()`.
+LYNX_CAPI_EXPORT char* lynx_generic_resource_fetcher_intercept(
+    lynx_generic_resource_fetcher_t*, const char* url, bool should_decode);
+
+// -----------------------------------------------------------------------------
+
+LYNX_EXTERN_C_END
+
+#endif  // PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_GENERIC_RESOURCE_FETCHER_CAPI_H_

package/include/capi/lynx_group_capi.h

@@ -0,0 +1,42 @@
+// 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_GROUP_CAPI_H_
+#define PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_GROUP_CAPI_H_
+
+#include <stddef.h>
+
+#include "lynx_export.h"
+
+LYNX_EXTERN_C_BEGIN
+
+typedef struct lynx_group_t lynx_group_t;
+
+#define LYNX_SINGLE_GROUP "-1"
+
+// Create a group with the given. A unique ID will be generated as group ID.
+LYNX_CAPI_EXPORT lynx_group_t* lynx_group_create(const char* name);
+
+// Create a group with the given name and ID. If the ID is not provided, a
+// unique ID will be generated. The ID should ideally be set to
+// `LYNX_SINGLE_GROUP` Other values are considered experimental features and
+// should be used with caution.
+LYNX_CAPI_EXPORT lynx_group_t* lynx_group_create_with_id(const char* name,
+                                                         const char* id);
+
+// Sets the preload JavaScript file paths for a lynx group. This function allows
+// you to specify an array of JavaScript file paths that should be preloaded for
+// a given lynx group.
+LYNX_CAPI_EXPORT void lynx_group_set_preload_js_paths(lynx_group_t*,
+                                                      const char* paths[],
+                                                      size_t size);
+// Enables or disables the JavaScript group thread for a lynx group.
+LYNX_CAPI_EXPORT void lynx_group_set_enable_js_group_thread(lynx_group_t*,
+                                                            int enable);
+
+// Release the lynx group.
+LYNX_CAPI_EXPORT void lynx_group_release(lynx_group_t*);
+
+LYNX_EXTERN_C_END
+
+#endif  // PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_GROUP_CAPI_H_

package/include/capi/lynx_http_service_capi.h

@@ -0,0 +1,113 @@
+// 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_HTTP_SERVICE_CAPI_H_
+#define PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_HTTP_SERVICE_CAPI_H_
+
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "lynx_export.h"
+
+LYNX_EXTERN_C_BEGIN
+
+// Forward declaration of the lynx_http_request_t struct.
+typedef struct lynx_http_request_t lynx_http_request_t;
+// Retrieves the URL associated with the HTTP request. This function extracts
+// and returns the URL of the specified HTTP request. The caller should not free
+// the returned pointer.
+LYNX_CAPI_EXPORT const char* lynx_http_request_get_url(lynx_http_request_t*);
+// Retrieves the HTTP method of the specified request. This function extracts
+// and returns the HTTP method (such as "GET", "POST", "PUT", etc.) associated
+// with the given HTTP request. The caller should not free the returned pointer.
+LYNX_CAPI_EXPORT const char* lynx_http_request_get_method(lynx_http_request_t*);
+// Retrieves the HTTP method of the specified request. This function extracts
+// and returns the HTTP method (such as "GET", "POST", "PUT", etc.) associated
+// with the given HTTP request. The caller should not free the returned pointer.
+LYNX_CAPI_EXPORT size_t lynx_http_request_get_body(lynx_http_request_t*,
+                                                   const uint8_t** data);
+// Retrieves the number of headers in the specified HTTP request. This function
+// counts and returns the number of headers associated with the given HTTP
+// request. The returned value can be used to iterate over all headers using
+// `lynx_http_request_get_header`.
+LYNX_CAPI_EXPORT size_t
+lynx_http_request_get_header_count(lynx_http_request_t*);
+// Retrieves a header from the specified HTTP request by index. This function
+// fetches the header key and value at the given index from the HTTP request.
+// The index should be in the range `[0,
+// lynx_http_request_get_header_count(request))`. The caller should not free the
+// returned pointers, as their lifetimes are managed by the
+// `lynx_http_request_t` object.
+LYNX_CAPI_EXPORT void lynx_http_request_get_header(lynx_http_request_t*,
+                                                   uint32_t index,
+                                                   const char** key,
+                                                   const char** value);
+// Releases the resources associated with an HTTP request.
+LYNX_CAPI_EXPORT void lynx_http_request_release(lynx_http_request_t*);
+
+// Forward declaration of the lynx_http_response_t struct.
+typedef struct lynx_http_response_t lynx_http_response_t;
+// Sets the URL of an HTTP response. This function allows you to specify the URL
+// of the given HTTP response object.
+LYNX_CAPI_EXPORT void lynx_http_response_set_url(lynx_http_response_t*,
+                                                 const char* url);
+// Sets the status code of an HTTP response. This function allows you to specify
+// the status code of the given HTTP response object. Status codes are used to
+// indicate the outcome of an HTTP request, such as 200 for success, 404 for not
+// found, etc.
+LYNX_CAPI_EXPORT void lynx_http_response_set_status_code(lynx_http_response_t*,
+                                                         int status_code);
+// Sets the status text of an HTTP response. This function allows you to specify
+// the status text associated with the HTTP response. The status text provides a
+// human - readable description corresponding to the status code. For example,
+// "OK" for status code 200, "Not Found" for status code 404. The caller should
+// not free the memory of the passed `status_text` pointer.
+LYNX_CAPI_EXPORT void lynx_http_response_set_status_text(
+    lynx_http_response_t*, const char* status_text);
+// Adds a header to the specified HTTP response. This function allows you to add
+// a new header to the given HTTP response object. Headers are used to provide
+// additional information about the response, such as content type, caching
+// directives, etc.
+LYNX_CAPI_EXPORT void lynx_http_response_add_header(lynx_http_response_t*,
+                                                    const char* key,
+                                                    const char* value);
+// Sets the body content of an HTTP response. This function allows you to
+// specify the body content of the given HTTP response object. You can also
+// provide a custom destructor function to handle the cleanup of the content
+// memory, and pass an opaque pointer for additional context.
+LYNX_CAPI_EXPORT void lynx_http_response_set_body(
+    lynx_http_response_t*, uint8_t* content, size_t length,
+    void (*dtor)(uint8_t*, size_t, void*), void* opaque);
+// Triggers the callback associated with an HTTP response. This function invokes
+// the callback that is related to the specified HTTP response object. This
+// function must be called when the response is ready or failed.
+LYNX_CAPI_EXPORT void lynx_http_response_callback(lynx_http_response_t*);
+// Releases the resources associated with an HTTP response.
+LYNX_CAPI_EXPORT void lynx_http_response_release(lynx_http_response_t*);
+
+typedef struct lynx_http_service_t lynx_http_service_t;
+// Define a function pointer type for HTTP request handling.
+typedef void (*lynx_http_request_func)(lynx_http_service_t*,
+                                       lynx_http_request_t* request,
+                                       lynx_http_response_t* response);
+// Creates a new HTTP service instance.
+LYNX_CAPI_EXPORT lynx_http_service_t* lynx_http_service_create(void* user_data);
+// Create a new HTTP 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_http_service_t* lynx_http_service_create_with_finalizer(
+    void* user_data, void (*finalizer)(lynx_http_service_t*, void*));
+// Retrieves the user data associated with an HTTP service.
+LYNX_CAPI_EXPORT void* lynx_http_service_get_user_data(lynx_http_service_t*);
+// Binds an HTTP request handling function to an HTTP service. This function
+// associates the specified HTTP request handling function with the given HTTP
+// service. Whenever an HTTP request is received by the service, the bound
+// function will be invoked to process the request.
+LYNX_CAPI_EXPORT void lynx_http_service_bind(lynx_http_service_t*,
+                                             lynx_http_request_func f);
+// Releases the resources associated with an HTTP service.
+LYNX_CAPI_EXPORT void lynx_http_service_release(lynx_http_service_t*);
+
+LYNX_EXTERN_C_END
+
+#endif  // PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_HTTP_SERVICE_CAPI_H_

package/include/capi/lynx_load_meta_capi.h

@@ -0,0 +1,52 @@
+// 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_LOAD_META_CAPI_H_
+#define PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_LOAD_META_CAPI_H_
+
+#include "lynx_export.h"
+#include "lynx_template_bundle_capi.h"
+#include "lynx_template_data_capi.h"
+
+LYNX_EXTERN_C_BEGIN
+
+// LynxLoadMeta is the metadata structure used by LynxView to load templates. It
+// will be used as the input parameter of loadTemplate. Users can use
+// LynxLoadMeta to specify many parameters of loading templates, such as
+// specifying template content, template initial data, and other additional
+// configuration information. url, binary_data, bundle are the required
+// parameters for template loading. You can pass only one or all of them. The
+// priority relationship is as follows: bundle > binary_data > url.
+typedef struct lynx_load_meta_t lynx_load_meta_t;
+
+LYNX_CAPI_EXPORT lynx_load_meta_t* lynx_load_meta_create();
+
+// The file path of the template.
+LYNX_CAPI_EXPORT void lynx_load_meta_set_url(lynx_load_meta_t*, const char*);
+
+// The binary file data of the template. You can also
+// provide a custom destructor function to handle the cleanup of the content
+// memory, and pass an opaque pointer for additional context.
+LYNX_CAPI_EXPORT void lynx_load_meta_set_binary_data(
+    lynx_load_meta_t*, uint8_t* content, size_t length,
+    void (*dtor)(uint8_t*, size_t, void*), void* opaque);
+
+// TemplateBundle object parsed in advance by the template's binary file data
+LYNX_CAPI_EXPORT void lynx_load_meta_set_template_bundle(
+    lynx_load_meta_t*, lynx_template_bundle_t*);
+
+// Set the initial data for the template. Initial data specified by the client
+// during the first screen loading process
+LYNX_CAPI_EXPORT void lynx_load_meta_set_initial_data(lynx_load_meta_t*,
+                                                      lynx_template_data_t*);
+
+// Set the global props data for the template.
+LYNX_CAPI_EXPORT void lynx_load_meta_set_global_props(lynx_load_meta_t*,
+                                                      lynx_template_data_t*);
+
+// Release the load meta.
+LYNX_CAPI_EXPORT void lynx_load_meta_release(lynx_load_meta_t*);
+
+LYNX_EXTERN_C_END
+
+#endif  // PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_LOAD_META_CAPI_H_

package/include/capi/lynx_log_capi.h

@@ -0,0 +1,69 @@
+// 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_LOG_CAPI_H_
+#define PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_LOG_CAPI_H_
+
+#include "lynx_export.h"
+
+LYNX_EXTERN_C_BEGIN
+
+// Defines the log levels for the Lynx logging system.
+typedef enum lynx_log_level_e {
+  LYNX_LOG_VERBOSE = 0,
+  LYNX_LOG_DEBUG,
+  LYNX_LOG_INFO,
+  LYNX_LOG_WARNING,
+  LYNX_LOG_ERROR,
+  LYNX_LOG_FATAL,
+} lynx_log_level_e;
+
+// Callback function type for receiving Lynx log messages.
+// @param level The severity level of the log message.
+// @param tag A string identifying the source or context of the log message.
+// @param msg The actual log message content.
+typedef void (*lynx_log_callback_t)(lynx_log_level_e level, const char* tag,
+                                    const char* msg);
+
+// Initializes the Lynx logging system with a custom callback.
+// @param callback The function pointer to be invoked for logging.
+LYNX_CAPI_EXPORT void lynx_log_init(lynx_log_callback_t callback);
+
+// Sets the minimum severity level for logs to be output.
+// Logs with a level lower than this will be ignored.
+// @param min_log_level The minimum log level to set.
+LYNX_CAPI_EXPORT void lynx_log_set_minimum_level(
+    lynx_log_level_e min_log_level);
+
+// Retrieves the current minimum log level.
+// @return The current minimum log level.
+LYNX_CAPI_EXPORT lynx_log_level_e lynx_log_get_minimum_level();
+
+// Writes a log message to the Lynx logging system.
+// This function supports printf-style formatting.
+// @param level The log level for the message.
+// @param tag A tag to identify the source of the log message.
+// @param format The printf-style format string.
+// @param ... Additional arguments for the format string.
+LYNX_CAPI_EXPORT void lynx_log_write_detailed(lynx_log_level_e level,
+                                              const char* tag, const char* file,
+                                              int line, const char* format,
+                                              ...);
+
+#ifdef __FILE_NAME__
+#define __LYNX_CAPI_LOG_FILE__ __FILE_NAME__
+#else
+#define __LYNX_CAPI_LOG_FILE__ __FILE__
+#endif
+
+// The primary logging macro for external C-API consumers.
+// This captures the file and line number automatically.
+// Example: LYNX_CAPI_LOG(LYNX_LOG_INFO, "MyTag", "User ID: %d", 123);
+#define LYNX_CAPI_LOG(level, tag, format, ...)                          \
+  lynx_log_write_detailed(level, tag, __LYNX_CAPI_LOG_FILE__, __LINE__, \
+                          format, ##__VA_ARGS__)
+
+LYNX_EXTERN_C_END
+
+#endif  // PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_LOG_CAPI_H_

package/include/capi/lynx_memory_capi.h

@@ -0,0 +1,28 @@
+// 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_MEMORY_CAPI_H_
+#define PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_MEMORY_CAPI_H_
+
+#include <stddef.h>
+
+#include "lynx_export.h"
+
+LYNX_EXTERN_C_BEGIN
+
+// Allocates memory of `size` bytes. The memory is not initialized.
+// The returned pointer must be deallocated with `lynx_free()`.
+LYNX_CAPI_EXPORT void* lynx_malloc(size_t size);
+
+// Deallocates the memory previously allocated by `lynx_malloc()` or
+// `lynx_strdup()`. If `ptr` is a null pointer, no operation is performed.
+LYNX_CAPI_EXPORT void lynx_free(void* ptr);
+
+// Duplicates the string `s`. Memory for the new string is obtained with
+// `lynx_malloc()`, and can be freed with `lynx_free()`.
+LYNX_CAPI_EXPORT char* lynx_strdup(const char* s);
+
+LYNX_EXTERN_C_END
+
+#endif  // PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_MEMORY_CAPI_H_

package/include/capi/lynx_native_module_capi.h

@@ -0,0 +1,51 @@
+// 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_NATIVE_MODULE_CAPI_H_
+#define PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_NATIVE_MODULE_CAPI_H_
+
+#include "lynx_export.h"
+#include "third_party/weak-node-api/headers/node_api.h"
+
+#ifdef USE_WEAK_SUFFIX_NAPI
+#include "third_party/weak-node-api/headers/weak_napi_defines.h"
+#endif
+
+LYNX_EXTERN_C_BEGIN
+
+#define LYNX_NAPI_ENV_LYNX_VIEW_TAG 0xAC7F
+
+typedef napi_value (*napi_module_creator)(napi_env, napi_value exports,
+                                          const char* module_name,
+                                          void* opaque);
+
+// Stores a data with key to the global map.
+LYNX_CAPI_EXPORT void lynx_napi_set_instance_data(napi_env env, uint64_t key,
+                                                  void* data,
+                                                  napi_finalize finalize_cb,
+                                                  void* finalize_hint);
+LYNX_CAPI_EXPORT void lynx_napi_get_instance_data(napi_env env, uint64_t key,
+                                                  void** data);
+
+// Runs a script from the provided source content in the given NAPI
+// environment. This is not part of the standard NAPI surface, but Lynx needs
+// to expose it as an embedder-specific helper for loading and evaluating script
+// content with explicit source metadata. `filename` is used for script
+// identification in diagnostics and stack traces.
+LYNX_CAPI_EXPORT napi_status
+lynx_napi_run_script_from_file(napi_env env, const char* script, size_t length,
+                               const char* filename, napi_value* result);
+
+// Reports the current exception associated with the given NAPI environment and
+// then clears the recorded exception state. This is also a Lynx-specific
+// extension instead of a standard NAPI API, provided because the embedder needs
+// an explicit hook to consume and reset pending exception information.
+LYNX_CAPI_EXPORT void lynx_napi_report_and_clear_exception(napi_env env);
+
+LYNX_EXTERN_C_END
+
+#ifdef USE_WEAK_SUFFIX_NAPI
+#include "third_party/weak-node-api/headers/weak_napi_undefs.h"
+#endif
+
+#endif  // PLATFORM_EMBEDDER_PUBLIC_CAPI_LYNX_NATIVE_MODULE_CAPI_H_