void JS_SetRuntimeInfo(JSRuntime *rt, const char *info);

#include <quickjs.h>

int main() {
    JSRuntime *rt = JS_NewRuntime();
    
    // Set runtime info (must be a persistent string)
    JS_SetRuntimeInfo(rt, "Main Application Runtime");
    
    // The info string will be used in debug output
    JSContext *ctx = JS_NewContext(rt);
    
    // ... use runtime ...
    
    JS_FreeContext(ctx);
    JS_FreeRuntime(rt);
    return 0;
}

// Multiple runtimes with different info strings
JSRuntime *worker_rt = JS_NewRuntime();
JS_SetRuntimeInfo(worker_rt, "Worker Runtime");

JSRuntime *main_rt = JS_NewRuntime();
JS_SetRuntimeInfo(main_rt, "Main Runtime");

void JS_SetRuntimeOpaque(JSRuntime *rt, void *opaque);

#include <quickjs.h>
#include <stdlib.h>

typedef struct {
    int request_count;
    char *app_name;
    void *user_data;
} AppContext;

int main() {
    JSRuntime *rt = JS_NewRuntime();
    
    // Create and attach custom context
    AppContext *app_ctx = malloc(sizeof(AppContext));
    app_ctx->request_count = 0;
    app_ctx->app_name = strdup("MyApp");
    app_ctx->user_data = NULL;
    
    JS_SetRuntimeOpaque(rt, app_ctx);
    
    // Now you can retrieve it from C functions
    JSContext *ctx = JS_NewContext(rt);
    
    // ... use runtime ...
    
    // Clean up opaque data before freeing runtime
    AppContext *ctx_to_free = JS_GetRuntimeOpaque(rt);
    if (ctx_to_free) {
        free(ctx_to_free->app_name);
        free(ctx_to_free);
    }
    
    JS_FreeContext(ctx);
    JS_FreeRuntime(rt);
    return 0;
}

// Accessing opaque data from a C function
static JSValue js_get_request_count(JSContext *ctx, JSValueConst this_val,
                                     int argc, JSValueConst *argv) {
    JSRuntime *rt = JS_GetRuntime(ctx);
    AppContext *app_ctx = JS_GetRuntimeOpaque(rt);
    
    if (app_ctx) {
        return JS_NewInt32(ctx, app_ctx->request_count);
    }
    return JS_NewInt32(ctx, 0);
}

void *JS_GetRuntimeOpaque(JSRuntime *rt);

#include <quickjs.h>

typedef struct {
    int max_iterations;
    bool debug_mode;
} Config;

static JSValue js_run_task(JSContext *ctx, JSValueConst this_val,
                           int argc, JSValueConst *argv) {
    JSRuntime *rt = JS_GetRuntime(ctx);
    Config *config = JS_GetRuntimeOpaque(rt);
    
    if (!config) {
        return JS_ThrowInternalError(ctx, "No runtime configuration");
    }
    
    if (config->debug_mode) {
        printf("Running task with max_iterations=%d\n", config->max_iterations);
    }
    
    // ... perform task ...
    
    return JS_UNDEFINED;
}

int main() {
    JSRuntime *rt = JS_NewRuntime();
    JSContext *ctx = JS_NewContext(rt);
    
    Config config = { .max_iterations = 1000, .debug_mode = true };
    JS_SetRuntimeOpaque(rt, &config);
    
    // Register the C function
    JSValue global = JS_GetGlobalObject(ctx);
    JS_SetPropertyStr(ctx, global, "runTask",
                      JS_NewCFunction(ctx, js_run_task, "runTask", 0));
    JS_FreeValue(ctx, global);
    
    // JavaScript can now call runTask()
    JS_Eval(ctx, "runTask();", 10, "<input>", JS_EVAL_TYPE_GLOBAL);
    
    JS_FreeContext(ctx);
    JS_FreeRuntime(rt);
    return 0;
}

// 1. Storing application state
typedef struct {
    sqlite3 *db;
    FILE *log_file;
    int user_id;
} AppState;

AppState state;
JS_SetRuntimeOpaque(rt, &state);

// 2. Passing callbacks
typedef struct {
    void (*on_error)(const char *msg);
    void (*on_complete)(void);
} Callbacks;

Callbacks callbacks = {
    .on_error = handle_error,
    .on_complete = handle_complete
};
JS_SetRuntimeOpaque(rt, &callbacks);

// 3. Configuration management
typedef struct {
    const char *data_dir;
    size_t max_memory;
    bool enable_networking;
} RuntimeConfig;

RuntimeConfig config;
JS_SetRuntimeOpaque(rt, &config);