marsrs-react-native-xlog 0.1.0-alpha.2

package/README.md

@@ -0,0 +1,88 @@
+# marsrs-react-native-xlog
+
+The React Native module of the xlog half of
+[mars-rs](https://github.com/orangeboyChen/mars-rs), a Rust implementation of
+[Tencent/mars](https://github.com/Tencent/mars): it writes the `.xlog` the C++
+implementation produced, encrypted or plain, zlib- or zstd-compressed, sync or
+async.
+
+```ts
+import { Xlog, LogLevel } from 'marsrs-react-native-xlog';
+
+const xlog = Xlog.open({
+  logDir: RNFS.DocumentDirectoryPath,
+  namePrefix: 'marsrs',
+  pubKey: '...',
+});
+xlog.i('Net', 'hello');
+xlog.log(LogLevel.Debug, 'Net', 'a debug line');
+xlog.flush(true);
+xlog.close();
+```
+
+`Xlog` is one appender: `Xlog.open(config)` opens it and `close()` closes it —
+the same class, under the same name, the Swift package,
+`platforms/kmp/marsrs-xlog` and the Android AAR publish. Nothing here answers
+a `Promise` and nothing needs an `await`: the module is a TurboModule, so a
+call is made on the JS thread and returned from, and the settings are the
+properties they are in Kotlin and in Swift — `xlog.level = LogLevel.Debug` —
+and not `setLevel` / `getLevel` pairs.
+
+That is what the New Architecture buys, and it is the only thing asked for in
+return: a TurboModule is not a bridge module, so an app still on the old
+architecture has no module to `TurboModuleRegistry.getEnforcing`.
+
+## Installing it
+
+`npm install marsrs-react-native-xlog`, and `pod install` for the iOS half: the
+module is published to npm, and the release of a tag is what publishes it.
+
+```bash
+npm install marsrs-react-native-xlog
+cd ios && pod install
+```
+
+| | |
+|---|---|
+| version | the version of the release; `npm install` takes the newest published one |
+| React Native | >= 0.74, on the New Architecture |
+| iOS | 12.0 |
+| Android | `minSdk` 24 |
+
+The package ships its TypeScript as the `main` entry, which is what Metro
+compiles — there is no build step, and `npm run typecheck` is the only script.
+`src/NativeXlog.ts` is the spec React Native's codegen reads, and
+`codegenConfig` in `package.json` is what points it at `src`: `NativeXlogSpec`
+is generated into the app's `React-Codegen` pod and into the Android build, and
+neither half of the module has to be told the eleven signatures twice.
+
+## What each platform resolves
+
+The two halves do not get their native the same way, and the difference is the
+ecosystem's, not the port's:
+
+* **Android** depends on the `xlog` AAR of the same version
+  (`io.github.orangeboychen.marsrs:xlog`) from JitPack — the same coordinate,
+  resolved the same way, as for an app that takes the AAR directly. The `.so`
+  files are the AAR's, so nothing is built here and nothing Rust is needed.
+* **iOS** carries `marsrs-xlog.xcframework` with it, in `ios/Frameworks`, and
+  `mars_xlog.h` next to it in `ios/include`. CocoaPods cannot resolve the SwiftPM
+  binary target of `Package.swift`, and there is no CocoaPods pod for it, so the
+  release drops the framework of its own tag into the package before packing it.
+
+Both files arrive with the release and not with this directory: what is checked
+in is the module, and `scripts/package_react_native.sh` is what makes a complete
+package out of it.
+
+## Why it is called xlog's
+
+The C ABI is 28 `mars_xlog_*` symbols and nothing else, and
+`scripts/build_xcframework.sh` fails the day it is not — the same reason the
+framework and the AAR are called xlog's. `marsrs-react-native` is the umbrella
+the whole port joins under: STN and SDT land there and not here, so an app that
+only logs keeps this one and downloads nothing it does not call. Today the two
+are the same module under two names, and taking the umbrella costs exactly what
+this one costs.
+
+Take one of the two and not both: both carry the same `libmarsrsxlog.so`, and an
+app with two of it does not build.

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -0,0 +1,2 @@
+#Mon Sep 28 14:47:25 CST 2026
+gradle.version=9.2.0

package/android/build.gradle.kts

@@ -0,0 +1,49 @@
+// The Android half of `marsrs-react-native-xlog`: a `ReactPackage` over `Xlog`,
+// the Kotlin face of `libmarsrsxlog.so` in the `xlog` AAR.
+// `marsrs-react-native` is the same module over the `marsrs` AAR — the whole
+// port, which today is the same xlog — and it is the one an app takes when it
+// wants more than logging.
+//
+// Nothing is compiled from Rust here, and no `.so` is packaged either: the AAR
+// of the release this module was packaged for carries them, which is what the
+// dependency below is. `scripts/package_react_native.sh` stamps its version.
+
+plugins {
+    id("com.android.library")
+    // No version, and no `apply false`: the app that takes this module is the
+    // one that pins the Kotlin plugin, and Gradle resolves the request below
+    // from there. The AAR modules of `platforms/android/` need no plugin at
+    // all — their AGP is pinned by this repository and is 9, which compiles
+    // Kotlin on its own — but an app's is not, and is 8 today.
+    id("org.jetbrains.kotlin.android")
+}
+
+android {
+    namespace = "io.github.orangeboychen.marsrs.xlog.reactnative"
+    compileSdk = 36
+
+    defaultConfig {
+        // React Native's own floor since 0.76, and above the 24 `mars-jni` is
+        // built against.
+        minSdk = 24
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+    // `xlog`, the AAR of the release; JitPack is where it is published.
+    maven("https://jitpack.io")
+}
+
+dependencies {
+    // `react-android` and not `react-native`: the artifact React Native has
+    // published since 0.71, and the one the app's own repository resolves.
+    implementation("com.facebook.react:react-android")
+    implementation("io.github.orangeboychen.marsrs:xlog:0.1.0-alpha.2")
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest />

package/android/src/main/kotlin/io/github/orangeboychen/marsrs/xlog/reactnative/XlogModule.kt

@@ -0,0 +1,198 @@
+// The Android half of `marsrs-react-native-xlog`: the eleven methods of the
+// `Xlog` native module, each of them a straight call of a member of `Xlog` — the
+// Kotlin face of `libmarsrsxlog.so` in the `marsrs-xlog` AAR, and the same
+// class `platforms/kmp/marsrs-xlog` publishes to a Kotlin Multiplatform app
+// and `platforms/apple/MarsRSXlog/Xlog.swift` to a Swift one. So what this
+// file is is a native module over an API that already exists, and nothing of
+// the API is invented here: `Xlog.open(XlogConfig(...))`, `log`,
+// `isLoggable`, `flush`, `close`, and the five settings, under the names
+// every other platform of the port gives them.
+//
+// A TurboModule, and not a bridge module: `src/NativeXlog.ts` is the spec
+// codegen reads, and `NativeXlogSpec` — the abstract class it generates into
+// this package — is what this class extends. What that buys is a call that is
+// made where it is asked for and returned from: a method that answers no promise
+// is a call and not an `await`, and one that answers a value answers it before
+// the call returns. That, and only that, is why `src/index.ts` has no `Promise`
+// in it and no `await` in front of a line.
+//
+// `marsrs-react-native` is the same module over the `marsrs` AAR — the whole
+// port, which today is the same xlog — and this file is its Kotlin with the two
+// names changed: xlog is the whole C ABI today, so the two are one package under
+// two names, and they diverge the day STN and SDT land — there, and not here.
+//
+// Every key below is a field `src/index.ts` put there, and every number is the
+// one `mars_xlog.h` gives a level, a mode and a compression. The appenders are
+// kept by the prefix they were opened with because that is what an appender is
+// known by in the C ABI and in `marsrs-jni`: two `Xlog`s of two prefixes are
+// two appenders, and one of a prefix the module already has is the appender it
+// already has.
+
+package io.github.orangeboychen.marsrs.xlog.reactnative
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import io.github.orangeboychen.marsrs.xlog.AppenderMode
+import io.github.orangeboychen.marsrs.xlog.CompressMode
+import io.github.orangeboychen.marsrs.xlog.LogLevel
+import io.github.orangeboychen.marsrs.xlog.Xlog
+import io.github.orangeboychen.marsrs.xlog.XlogConfig
+import java.util.concurrent.ConcurrentHashMap
+
+/** The Android half of `Xlog`. */
+class XlogModule(reactContext: ReactApplicationContext) : NativeXlogSpec(reactContext) {
+
+    /**
+     * The appender of every prefix `open` has opened, by the prefix: what keeps
+     * two `Xlog`s apart, which a single field cannot — the C ABI and
+     * `marsrs-jni` both answer an appender by the name it was opened with.
+     */
+    private val appenders = ConcurrentHashMap<String, Xlog>()
+
+    /**
+     * `Xlog.open(XlogConfig(...))`: opens the appender of the configuration
+     * `src/index.ts` sent, and answers whether it took it.
+     *
+     * One appender per prefix: a prefix [appenders] already holds is answered
+     * as `true` without a second `Xlog` over the first, which would be a handle
+     * nothing releases. `src/index.ts` does the same, so the two names an app
+     * holds for one prefix are one appender and `close` on either closes it for
+     * both.
+     *
+     * [Xlog.open] is what refuses a configuration the appender cannot honour —
+     * a blank `logDir` or `namePrefix`, a compression level out of range — and
+     * its `IllegalArgumentException` is what would cross back into JS as a
+     * crash, so it is caught here and answered as `false`: the caller's mistake
+     * to throw on, and not one to take the app with.
+     */
+    override fun open(config: ReadableMap): Boolean {
+        val namePrefix = config.string("namePrefix").ifBlank { DEFAULT_NAME_PREFIX }
+        if (appenders.containsKey(namePrefix)) {
+            return true
+        }
+        val xlogConfig = XlogConfig(
+            logDir = config.string("logDir"),
+            namePrefix = namePrefix,
+            level = LogLevel.of(config.int("level", LogLevel.INFO.ordinal)),
+            mode = appenderModeOf(config.int("mode", AppenderMode.ASYNC.ordinal)),
+            pubKey = config.string("pubKey"),
+            compressMode = compressModeOf(config.int("compressMode", CompressMode.ZLIB.ordinal)),
+            compressLevel = config.int("compressLevel", DEFAULT_COMPRESS_LEVEL),
+            cacheDir = config.optionalString("cacheDir"),
+            cacheDays = config.int("cacheDays", NO_CACHE_DAYS)
+        )
+        val xlog = try {
+            Xlog.open(xlogConfig)
+        } catch (e: IllegalArgumentException) {
+            return false
+        }
+        appenders[xlogConfig.namePrefix] = xlog
+        return true
+    }
+
+    /**
+     * `Xlog.log`. The file, the function and the line are the C++'s own
+     * defaults: there is no JS frame to name, and the C++ writes an empty one
+     * too.
+     */
+    override fun log(namePrefix: String, level: Double, tag: String, message: String) {
+        appender(namePrefix)?.log(LogLevel.of(level.toInt()), tag, message)
+    }
+
+    /** `Xlog.isLoggable`: whether a record of the level would be written. */
+    override fun isLoggable(namePrefix: String, level: Double): Boolean =
+        appender(namePrefix)?.isLoggable(LogLevel.of(level.toInt())) ?: false
+
+    /** `Xlog.level`, read: what `marsrs-jni` answers, and not what JS holds. */
+    override fun getLevel(namePrefix: String): Double =
+        appender(namePrefix)?.level?.ordinal?.toDouble() ?: LogLevel.NONE.ordinal.toDouble()
+
+    /** `Xlog.flush`. */
+    override fun flush(namePrefix: String, sync: Boolean) {
+        appender(namePrefix)?.flush(sync)
+    }
+
+    /** `Xlog.level`. */
+    override fun setLevel(namePrefix: String, level: Double) {
+        appender(namePrefix)?.level = LogLevel.of(level.toInt())
+    }
+
+    /** `Xlog.mode`. */
+    override fun setMode(namePrefix: String, mode: Double) {
+        appender(namePrefix)?.mode = appenderModeOf(mode.toInt())
+    }
+
+    /** `Xlog.consoleLogEnabled`. */
+    override fun setConsoleLogEnabled(namePrefix: String, enabled: Boolean) {
+        appender(namePrefix)?.consoleLogEnabled = enabled
+    }
+
+    /** `Xlog.maxFileSizeBytes`. A `Double` and not a `Long`: the module carries
+     * every JS number as one, and a file size is below 2^53. */
+    override fun setMaxFileSize(namePrefix: String, bytes: Double) {
+        appender(namePrefix)?.maxFileSizeBytes = bytes.toLong()
+    }
+
+    /** `Xlog.maxAliveTimeSeconds`. */
+    override fun setMaxAliveTime(namePrefix: String, seconds: Double) {
+        appender(namePrefix)?.maxAliveTimeSeconds = seconds.toLong()
+    }
+
+    /** `Xlog.close`: releases the appender `open` made. */
+    override fun close(namePrefix: String) {
+        appenders.remove(namePrefix)?.close()
+    }
+
+    /**
+     * The appender of [namePrefix], or `null` when there is none — which is a
+     * no-op and not a crash, the same answer the Swift and the Kotlin give an
+     * `Xlog` that is closed: no appender is the process-wide one to
+     * `marsrs-jni`, so a call that went on without one would write through
+     * whatever appender the rest of the process writes through.
+     */
+    private fun appender(namePrefix: String): Xlog? = appenders[namePrefix]?.takeIf { it.isOpen }
+
+    internal companion object {
+        /** The name `src/index.ts` reads the module out of
+         * `TurboModuleRegistry` by — and the one codegen gave the generated
+         * `NativeXlogSpec`. */
+        const val NAME = "Xlog"
+
+        /** `XlogConfig.namePrefix` of the Kotlin, of the Swift and of the TS. */
+        private const val DEFAULT_NAME_PREFIX = "xlog"
+
+        /** `0` — what the C++ passes on, which is the appender's own 6. */
+        private const val DEFAULT_COMPRESS_LEVEL = 0
+
+        /** `0` keeps every log file, which is what the C++'s default is. */
+        private const val NO_CACHE_DAYS = 0
+
+        /**
+         * `AppenderMode` of the number `mars_xlog.h` gives a mode: an ordinal
+         * the enum does not carry is one the caller sent by mistake, and `ASYNC`
+         * is what the C++ opens with.
+         */
+        fun appenderModeOf(ordinal: Int): AppenderMode = when (ordinal) {
+            AppenderMode.SYNC.ordinal -> AppenderMode.SYNC
+            else -> AppenderMode.ASYNC
+        }
+
+        /** `CompressMode` of the number `mars_xlog.h` gives a compression. */
+        fun compressModeOf(ordinal: Int): CompressMode = when (ordinal) {
+            CompressMode.ZSTD.ordinal -> CompressMode.ZSTD
+            else -> CompressMode.ZLIB
+        }
+    }
+}
+
+/** The number sent for [key], or [fallback] when none was sent: a field
+ * `src/index.ts` left out is not one it sent as `null`. */
+private fun ReadableMap.int(key: String, fallback: Int): Int = if (hasKey(key)) getInt(key) else fallback
+
+/** The string sent for [key], or the empty one. */
+private fun ReadableMap.string(key: String): String = if (hasKey(key)) getString(key).orEmpty() else ""
+
+/** The string sent for [key], or `null` — `cacheDir` is the field a caller may
+ * leave out, and `null` is what puts the cache in the log directory. */
+private fun ReadableMap.optionalString(key: String): String? =
+    if (hasKey(key)) getString(key)?.takeIf { it.isNotBlank() } else null

package/android/src/main/kotlin/io/github/orangeboychen/marsrs/xlog/reactnative/XlogPackage.kt

@@ -0,0 +1,65 @@
+// The `ReactPackage` of the Android half of `marsrs-react-native-xlog`.
+//
+// Autolinking finds this class by the `ReactPackage` it is and the
+// `react-native` directory it is in: it is what puts `XlogModule` in React
+// Native's hands, and nothing in the app has to name either of them.
+//
+// A `BaseReactPackage` and not a `ReactPackage`: `BaseReactPackage` is the one
+// that answers `getModule`, which is what React Native asks a TurboModule for,
+// and the `ReactModuleInfo` below is what tells it this module is one. A package
+// that only answered `createNativeModules` would be handed to the bridge, and
+// every call would be a promise again — which is the whole of what
+// `src/index.ts` is not.
+
+package io.github.orangeboychen.marsrs.xlog.reactnative
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+/** The package of `Xlog`. */
+class XlogPackage : BaseReactPackage() {
+
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
+        if (name == XlogModule.NAME) XlogModule(reactContext) else null
+
+    /**
+     * The one module this package has, and what React Native asks it about
+     * before it has an instance: its class, so that one can be made without
+     * asking, and `isTurboModule`, which is what sends the JSI after it rather
+     * than the bridge.
+     */
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider {
+        mapOf(
+            XlogModule.NAME to ReactModuleInfo(
+                XlogModule.NAME,
+                XlogModule::class.java.name,
+                CAN_OVERRIDE_EXISTING_MODULE,
+                NEEDS_EAGER_INIT,
+                HAS_CONSTANTS,
+                IS_CXX_MODULE,
+                IS_TURBO_MODULE
+            )
+        )
+    }
+
+    private companion object {
+        /** The module is the only one of its name an app has. */
+        const val CAN_OVERRIDE_EXISTING_MODULE = false
+
+        /** Nothing of the module is read before it is asked for. */
+        const val NEEDS_EAGER_INIT = false
+
+        /** The module carries no `constantsToExport`: a logger has none. */
+        const val HAS_CONSTANTS = false
+
+        /** Kotlin over a JNI bridge, and not a C++ module of React Native's
+         * own. */
+        const val IS_CXX_MODULE = false
+
+        /** What makes `src/index.ts` synchronous. */
+        const val IS_TURBO_MODULE = true
+    }
+}

package/ios/Xlog-Bridging-Header.h

@@ -0,0 +1,14 @@
+// What the Swift of the pod sees of the C ABI: `mars_xlog.h`, copied out of
+// `crates/marsrs-ffi/include` by `scripts/package_react_native.sh` rather than
+// kept here, so it cannot drift from the header the Rust is built against.
+//
+// A bridging header and not an `import`, because the framework the pod carries
+// is a static library with a C header: `MarsRSFFI`, the module SwiftPM makes of
+// the two, is nothing CocoaPods can hand a pod.
+//
+// React Native is not here, and that is the point: `Xlog.swift` conforms to no
+// React Native protocol, because the one it would conform to — `NativeXlogSpec`,
+// which codegen wrote — is declared in a header that refuses to be imported by
+// anything but Objective-C++. What the module owes React Native instead is in
+// `Xlog.mm`, which says why there.
+#include "mars_xlog.h"

package/ios/Xlog.mm

@@ -0,0 +1,63 @@
+// The one file of the iOS half of `marsrs-react-native-xlog` that Swift cannot
+// be, and why: a TurboModule is made of a factory that answers a
+// `std::shared_ptr<facebook::react::TurboModule>`, and `NativeXlogSpecJSI` — the
+// C++ class codegen wrote out of `src/NativeXlog.ts` — is a class of templates
+// and jsi types. Neither has a Swift spelling: Swift's C++ interop stops at
+// templates and at the standard library. So what is here is the three things
+// React Native asks a module for and cannot read out of `Xlog.swift`, and the
+// eleven methods are there and not here.
+//
+//   * `RCT_EXTERN_MODULE` registers the Swift class, which Swift cannot do for
+//     itself — registration is a constructor the runtime runs, and a Swift class
+//     has no `+load`. It is also what gives the class its `moduleName`, which is
+//     the name `src/index.ts` reads it out of `TurboModuleRegistry` by.
+//   * `RCTTurboModule` is adopted here, in a category, and not in the Swift:
+//     its one method is the C++ factory above, so a Swift class can neither name
+//     it nor be asked about it. `conformsToProtocol:` still answers `YES`, which
+//     is what `RCTTurboModuleManager` asks before it hands a module to JSI.
+//   * `methodQueue` answers `RCTJSThread`, the queue that is no queue: it is
+//     what makes a TurboModule's methods run on the JS thread, so a call is made
+//     where it is asked for and a method that answers a value answers it before
+//     it returns. Without it the eleven would be dispatched to a queue of the
+//     module's own and every answer would arrive as `undefined`.
+//
+// Objective-C++, and not Objective-C, because of the one `#include` a Swift
+// class cannot make: `RCTNativeXlogSpec.h` opens with
+// `#error This file must be compiled as Obj-C++`, and with good reason — it
+// declares a C++ class.
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTJSThread.h>
+#import <React/RCTTurboModule.h>
+
+// What codegen wrote out of `src/NativeXlog.ts`: the protocol `NativeXlogSpec`
+// and the C++ class `NativeXlogSpecJSI`, in one header. React Native names the
+// file, and renamed it once — `RCTNativeXlogSpec.h` since 0.74,
+// `NativeXlogSpec.h` before — so both spellings are asked for.
+#if __has_include(<React-Codegen/RCTNativeXlogSpec.h>)
+#import <React-Codegen/RCTNativeXlogSpec.h>
+#else
+#import <React-Codegen/NativeXlogSpec.h>
+#endif
+
+// `Xlog`, the Swift class, registered under the name `src/index.ts` reads it by.
+@interface RCT_EXTERN_MODULE(Xlog, NSObject)
+@end
+
+@interface Xlog (XlogTurboModule) <RCTTurboModule>
+@end
+
+@implementation Xlog (XlogTurboModule)
+
+- (dispatch_queue_t)methodQueue
+{
+  return RCTJSThread;
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeXlogSpecJSI>(params);
+}
+
+@end

package/ios/Xlog.swift

@@ -0,0 +1,253 @@
+// The iOS half of `marsrs-react-native-xlog`: the eleven methods of the `Xlog`
+// native module, each of them a straight call of a `mars_xlog_*` symbol — the
+// C ABI of `crates/marsrs-ffi`, in the `marsrs-xlog.xcframework` the pod carries.
+//
+// Swift, and not Objective-C — except for `Xlog.mm`, which is the one file of
+// the module Swift cannot be, and which says why in its own header: a
+// TurboModule is made of a factory that answers a `std::shared_ptr` of a C++
+// class, and there is no Swift for either.
+//
+// The module is a TurboModule and not a bridge module. `src/NativeXlog.ts` is
+// the spec codegen reads, and what it makes of it — `NativeXlogSpec`, the
+// protocol, and `NativeXlogSpecJSI`, the C++ class behind it — is what lets a
+// call land where it is asked for rather than cross a bridge on a queue: the
+// module answers `RCTJSThread` as its method queue, and every method of it is
+// therefore made on the JS thread and returned from. A method that answers no
+// promise is a call and not an `await`, which is why `src/index.ts` can be the
+// Kotlin and the Swift of the port member for member.
+//
+// The appenders are kept by the prefix they were opened with, because that is
+// what an appender is known by in the C ABI: two `Xlog`s of two prefixes are two
+// appenders, and one of a prefix the module already has is the appender it
+// already has.
+//
+// `marsrs-react-native` is the whole-port module, and this file is its Swift
+// with the two names changed: xlog is the whole C ABI today, so the two are one
+// package under two names, and they diverge the day STN and SDT land — there,
+// and not here.
+
+import Foundation
+
+/// The iOS half of `Xlog`.
+///
+/// `Xlog` and no suffix: the name `src/index.ts` reads the module out of
+/// `TurboModuleRegistry` by is the class's.
+@objc(Xlog)
+internal final class Xlog: NSObject {
+    /// The handle of the appender of every prefix `open` has opened, by the
+    /// prefix: what keeps two `Xlog`s apart, which one handle cannot, because
+    /// the appender a `mars_xlog_release_instance` releases is the one of the
+    /// prefix it is given.
+    ///
+    /// Written and read on the JS thread and nowhere else, which is what the
+    /// module's `RCTJSThread` method queue makes true: the dictionary is not
+    /// locked, and a logger asked to wait for one would be a logger an app
+    /// routes around.
+    private var handles: [String: Int64] = [:]
+
+    /// `mars_xlog_new_instance`: opens the appender of `config` and answers
+    /// whether it took the configuration.
+    ///
+    /// `false` is a configuration it refused — an empty `logDir` or
+    /// `namePrefix`, or a directory it cannot write to — and it is what the JS
+    /// caller turns into a throw rather than a handle it would write through
+    /// the process-wide appender with.
+    @objc(open:)
+    internal func openAppender(_ config: [AnyHashable: Any]) -> Bool {
+        let logDir = string(config, "logDir")
+        guard !logDir.isEmpty else {
+            return false
+        }
+        let namePrefix = string(config, "namePrefix").isEmpty
+            ? Self.defaultNamePrefix
+            : string(config, "namePrefix")
+        // One appender per prefix: a prefix this module has already opened is
+        // answered as it is, and not opened again over the first, which would be
+        // a handle nothing releases. `src/index.ts` keeps the same map, so the
+        // two names an app holds for one prefix are one appender, and `close` on
+        // either is `close` on both.
+        guard handles[namePrefix] == nil else {
+            return true
+        }
+        let level = int(config, "level", Int32(MarsLevelInfo.rawValue))
+        let mode = int(config, "mode", Int32(MarsAppenderAsync.rawValue))
+        let compressMode = int(config, "compressMode", Int32(MarsCompressZlib.rawValue))
+        let compressLevel = int(config, "compressLevel", Self.defaultCompressLevel)
+        let cacheDays = int(config, "cacheDays", Self.keepEveryFile)
+
+        var handle: Int64 = 0
+        // `pubKey` and `cacheDir` are the two fields a caller may leave out, and
+        // `mars_xlog.h` reads the empty string the way it reads `NULL`.
+        withCStrings([logDir, namePrefix, string(config, "pubKey"), string(config, "cacheDir")]) { pointers in
+            var native = MarsXLogConfig(
+                mode: mode,
+                log_dir: pointers[Field.logDir.rawValue],
+                name_prefix: pointers[Field.namePrefix.rawValue],
+                pub_key: pointers[Field.pubKey.rawValue],
+                compress_mode: compressMode,
+                compress_level: compressLevel,
+                cache_dir: pointers[Field.cacheDir.rawValue],
+                cache_days: cacheDays
+            )
+            handle = mars_xlog_new_instance(&native, level)
+        }
+        guard handle != 0 else {
+            return false
+        }
+        handles[namePrefix] = handle
+        return true
+    }
+
+    /// `mars_xlog_write_instance`. The file, the function and the line are left
+    /// empty: there is no JS frame to name, and the C++ writes an empty one too.
+    @objc(log:level:tag:message:)
+    internal func log(_ namePrefix: String, level: Double, tag: String, message: String) {
+        guard let handle = handles[namePrefix] else {
+            return
+        }
+        tag.withCString { cTag in
+            message.withCString { cMessage in
+                mars_xlog_write_instance(handle, Int32(level), cTag, nil, nil, 0, cMessage)
+            }
+        }
+    }
+
+    /// `mars_xlog_is_enabled_for`: whether a record of the level would be
+    /// written, which an app asks before it builds a message that is expensive
+    /// to build.
+    @objc(isLoggable:level:)
+    internal func isLoggable(_ namePrefix: String, level: Double) -> Bool {
+        guard let handle = handles[namePrefix] else {
+            return false
+        }
+        return mars_xlog_is_enabled_for(handle, Int32(level)) != 0
+    }
+
+    /// `mars_xlog_get_level`: what the appender answers, and not what JS holds.
+    @objc(getLevel:)
+    internal func level(of namePrefix: String) -> Double {
+        guard let handle = handles[namePrefix] else {
+            return Double(MARS_LEVEL_NONE)
+        }
+        return Double(mars_xlog_get_level(handle))
+    }
+
+    /// `mars_xlog_flush_instance`.
+    @objc(flush:sync:)
+    internal func flush(_ namePrefix: String, sync: Bool) {
+        guard let handle = handles[namePrefix] else {
+            return
+        }
+        mars_xlog_flush_instance(handle, sync ? 1 : 0)
+    }
+
+    /// `mars_xlog_set_level_instance`.
+    @objc(setLevel:level:)
+    internal func setLevel(_ namePrefix: String, level: Double) {
+        guard let handle = handles[namePrefix] else {
+            return
+        }
+        mars_xlog_set_level_instance(handle, Int32(level))
+    }
+
+    /// `mars_xlog_set_mode_instance`.
+    @objc(setMode:mode:)
+    internal func setMode(_ namePrefix: String, mode: Double) {
+        guard let handle = handles[namePrefix] else {
+            return
+        }
+        mars_xlog_set_mode_instance(handle, Int32(mode))
+    }
+
+    /// `mars_xlog_set_console_log_instance`.
+    @objc(setConsoleLogEnabled:enabled:)
+    internal func setConsoleLogEnabled(_ namePrefix: String, enabled: Bool) {
+        guard let handle = handles[namePrefix] else {
+            return
+        }
+        mars_xlog_set_console_log_instance(handle, enabled ? 1 : 0)
+    }
+
+    /// `mars_xlog_set_max_file_size_instance`. A `Double` and not a `UInt64`:
+    /// the module carries every JS number as one, and a file size is below
+    /// 2^53.
+    @objc(setMaxFileSize:bytes:)
+    internal func setMaxFileSize(_ namePrefix: String, bytes: Double) {
+        guard let handle = handles[namePrefix] else {
+            return
+        }
+        mars_xlog_set_max_file_size_instance(handle, UInt64(bytes))
+    }
+
+    /// `mars_xlog_set_max_alive_duration_instance`.
+    @objc(setMaxAliveTime:seconds:)
+    internal func setMaxAliveTime(_ namePrefix: String, seconds: Double) {
+        guard let handle = handles[namePrefix] else {
+            return
+        }
+        mars_xlog_set_max_alive_duration_instance(handle, Int64(seconds))
+    }
+
+    /// `mars_xlog_release_instance`: closes the appender `open` made.
+    @objc(close:)
+    internal func close(_ namePrefix: String) {
+        guard handles.removeValue(forKey: namePrefix) != nil else {
+            return
+        }
+        namePrefix.withCString { mars_xlog_release_instance($0) }
+    }
+
+    /// Closes what `open` opened and `close` was not asked about: the module
+    /// goes away with the bridge, and an appender is a file its writer thread
+    /// holds open.
+    deinit {
+        for namePrefix in handles.keys {
+            namePrefix.withCString { mars_xlog_release_instance($0) }
+        }
+        handles.removeAll()
+    }
+
+    /// `XlogConfig.namePrefix` of the Kotlin, of the Swift and of the TS: what
+    /// an appender is opened with when the caller gave none.
+    private static let defaultNamePrefix = "xlog"
+
+    /// What the C++ passes on, which is the appender's own 6.
+    private static let defaultCompressLevel: Int32 = 0
+
+    /// `0` keeps every log file, which is what the C++'s default is.
+    private static let keepEveryFile: Int32 = 0
+
+    /// The four fields of `MarsXLogConfig` that are C strings, in the order the
+    /// copies are made in: what names the index a pointer is read out of, which
+    /// is what a `pointers[2]` is not.
+    private enum Field: Int {
+        case logDir = 0
+        case namePrefix = 1
+        case pubKey = 2
+        case cacheDir = 3
+    }
+
+    /// Runs `body` with every one of `strings` as a C string, and frees the
+    /// copies it made: `MarsXLogConfig` holds pointers rather than copies, and a
+    /// Swift `String` has no C string of its own to hand out — `withCString` is
+    /// the answer for one, and a configuration is four at once.
+    private func withCStrings(_ strings: [String], body: ([UnsafePointer<CChar>?]) -> Void) {
+        let copies: [UnsafeMutablePointer<CChar>?] = strings.map { strdup($0) }
+        defer { copies.forEach { free($0) } }
+        body(copies.map { $0.map { UnsafePointer($0) } })
+    }
+
+    /// What the caller sent for `key`, read as a string; a field it left out is
+    /// not one it sent as `null`, and the empty string is what every field of
+    /// the configuration reads as "not given".
+    private func string(_ config: [AnyHashable: Any], _ key: String) -> String {
+        (config[key] as? String) ?? ""
+    }
+
+    /// What the caller sent for `key`, read as an `Int32`, or `fallback` when it
+    /// sent nothing: a `Number`, because JS has one number type and the codec
+    /// hands over whichever the value fits in.
+    private func int(_ config: [AnyHashable: Any], _ key: String, _ fallback: Int32) -> Int32 {
+        (config[key] as? NSNumber)?.int32Value ?? fallback
+    }
+}

package/marsrs-react-native-xlog.podspec

@@ -0,0 +1,57 @@
+# The iOS half of `marsrs-react-native-xlog`.
+#
+# `marsrs-xlog.xcframework` is carried here and not resolved: CocoaPods cannot
+# take the SwiftPM binary target of Package.swift, and there is no pod for it,
+# so `.github/workflows/release.yml` drops the release's framework into
+# `ios/Frameworks/` before the package is packed. `ios/include/mars_xlog.h` is
+# the C ABI's own header, copied by `scripts/package_react_native.sh` out of
+# `crates/marsrs-ffi/include` rather than kept here, so it cannot drift from it.
+#
+# The glue is Swift — `ios/Xlog.swift` — over the C header the framework
+# carries, because `MarsRSFFI`, the module SwiftPM makes of the two, is nothing
+# CocoaPods can hand a pod: `ios/Xlog-Bridging-Header.h` is what shows the Swift
+# `mars_xlog.h`, and `ios/Xlog.mm` is the one file of the module that has no
+# Swift spelling, which its own header says why.
+#
+# `React-Codegen` is what `src/NativeXlog.ts` is generated by: `NativeXlogSpec`,
+# the protocol, and `NativeXlogSpecJSI`, the C++ class `Xlog.mm` hands React
+# Native — a pod of the app's own `use_react_native!`, and the pod the generated
+# headers land in.
+#
+# The version is package.json's, and not a number of its own: one place a
+# release stamps.
+
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = package["name"]
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.author       = { "orangeboyChen" => "https://github.com/orangeboyChen" }
+  s.source       = { :git => "https://github.com/orangeboyChen/mars-rs.git",
+                     :tag => "v#{s.version}" }
+  # What Package.swift declares for iOS; the framework's own floor.
+  s.platform     = :ios, "12.0"
+  s.swift_version = "5.0"
+  s.source_files = "ios/*.{h,mm,swift}"
+  s.vendored_frameworks = "ios/Frameworks/marsrs-xlog.xcframework"
+  s.preserve_paths = "ios/include/mars_xlog.h"
+  # One header for the pod's Swift to be bridged to the C ABI with, and one for
+  # the app's to be bridged to this pod's ObjC with. The first is the module's
+  # own; the second is the one CocoaPods reads when it compiles a pod that mixes
+  # the two languages.
+  s.xcconfig     = { "HEADER_SEARCH_PATHS" => "\"$(PODS_TARGET_SRCROOT)/ios/include\"",
+                     "SWIFT_OBJC_BRIDGING_HEADER" => "\"$(PODS_TARGET_SRCROOT)/ios/Xlog-Bridging-Header.h\"" }
+  # `iana-time-zone` calls `CFTimeZone*`, and a Rust static library carries no
+  # link flags of its own: Package.swift names the framework for the same reason.
+  s.frameworks   = "CoreFoundation"
+  # React Native's own, in place of `s.dependency "React-Core"`: it is what the
+  # app's `use_react_native!` provides, and it keeps the pod off a version of
+  # React Native the app did not choose.
+  install_modules_dependencies(s)
+  s.dependency "React-Codegen"
+end

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "marsrs-react-native-xlog",
+  "version": "0.1.0-alpha.2",
+  "description": "React Native module for xlog, the logging half of mars-rs: a Rust implementation of Tencent/mars that writes the .xlog the C++ implementation produced.",
+  "license": "MIT",
+  "homepage": "https://github.com/orangeboyChen/mars-rs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/orangeboyChen/mars-rs.git",
+    "directory": "platforms/react-native/marsrs-xlog"
+  },
+  "bugs": {
+    "url": "https://github.com/orangeboyChen/mars-rs/issues"
+  },
+  "keywords": [
+    "mars",
+    "xlog",
+    "logging",
+    "react-native"
+  ],
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "files": [
+    "src",
+    "android",
+    "ios",
+    "*.podspec",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit"
+  },
+  "codegenConfig": {
+    "name": "NativeXlogSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "io.github.orangeboychen.marsrs.xlog.reactnative"
+    }
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-native": ">=0.74.0"
+  }
+}

package/src/NativeXlog.ts

@@ -0,0 +1,63 @@
+// The TurboModule spec of `Xlog`: the file codegen reads, and what
+// `src/index.ts` calls at runtime.
+//
+// Codegen makes two things of it — `NativeXlogSpec`, the abstract class the
+// Android half extends, and `NativeXlogSpec`, the protocol the iOS half conforms
+// to — and the two of them are what let a call land where it is made instead of
+// crossing a bridge: a TurboModule method that answers no promise is called on
+// the JS thread and returns, and one that answers a value answers it before it
+// returns. That is the only reason `src/index.ts` can be the Kotlin and the
+// Swift member for member — `Xlog.open(config)`, `xlog.level`,
+// `xlog.i(tag, message)` — where the bridge's eleven `Promise`s left it with a
+// `setLevel`, a `getLevel` and an `await` in front of every line.
+//
+// The configuration crosses as an `Object` and not as a declared type: codegen
+// reads this file and not the ones it imports, so `XlogConfig` is documented in
+// `src/index.ts`, where an app reads it — and a `ReadableMap` and an
+// `NSDictionary` is what the two halves take either way.
+
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  /** `Xlog.open`: whether the appender took the configuration. `false` is a
+   * configuration it refused, which is an empty `logDir` or `namePrefix`, or a
+   * directory it cannot write to. */
+  open(config: Object): boolean;
+
+  /** `mars_xlog_write_instance`. The file, the function and the line are left
+   * empty on the platform side: there is no JS frame to name, and the C++ writes
+   * an empty one too. */
+  log(namePrefix: string, level: number, tag: string, message: string): void;
+
+  /** `mars_xlog_is_enabled_for`: whether a record of the level would be written. */
+  isLoggable(namePrefix: string, level: number): boolean;
+
+  /** `mars_xlog_get_level`: the level the appender is at, and not the one JS
+   * holds. */
+  getLevel(namePrefix: string): number;
+
+  /** `mars_xlog_flush_instance`. */
+  flush(namePrefix: string, sync: boolean): void;
+
+  /** `mars_xlog_set_level_instance`. */
+  setLevel(namePrefix: string, level: number): void;
+
+  /** `mars_xlog_set_mode_instance`. */
+  setMode(namePrefix: string, mode: number): void;
+
+  /** `mars_xlog_set_console_log_instance`. */
+  setConsoleLogEnabled(namePrefix: string, enabled: boolean): void;
+
+  /** `mars_xlog_set_max_file_size_instance`. A `number` and not an `Int64`: the
+   * module carries every JS number as one, and a file size is below 2^53. */
+  setMaxFileSize(namePrefix: string, bytes: number): void;
+
+  /** `mars_xlog_set_max_alive_duration_instance`. */
+  setMaxAliveTime(namePrefix: string, seconds: number): void;
+
+  /** `mars_xlog_release_instance`: releases the appender `open` made. */
+  close(namePrefix: string): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('Xlog');

package/src/index.ts

@@ -0,0 +1,315 @@
+// The TypeScript face of the xlog half of mars-rs.
+//
+// A TurboModule, and not a bridge module: `src/NativeXlog.ts` is the spec
+// codegen reads, and what it answers is a module whose methods are called where
+// they are asked for and return before the next line runs — one that answers no
+// promise is a call and not an `await`, and one that answers a value answers it
+// before it returns. So this `Xlog` is the `Xlog` of
+// `platforms/apple/MarsRSXlog/Xlog.swift`, of
+// `platforms/android/marsrs-xlog` and of `platforms/kmp/marsrs-xlog` member
+// for member: `Xlog.open(config)` answers the appender, `xlog.level` is the
+// property it is in Kotlin and in Swift, and `xlog.i(tag, message)` has
+// landed by the time it returns.
+//
+// Five settings are properties and not `setLevel` / `getLevel` pairs, because a
+// JS property is the Kotlin and the Swift spelling and a TurboModule setter is
+// called where it is written: `xlog.level` reads the appender's own and writes
+// it, and `mode`, `consoleLogEnabled`, `maxFileSizeBytes` and
+// `maxAliveTimeSeconds` answer what this instance last wrote — the C ABI has no
+// getter for those four, and neither the Kotlin nor the Swift answers one.
+
+import NativeXlog from './NativeXlog';
+
+/** `TLogLevel`; `none` is `MARS_LEVEL_NONE`, which the filter understands but
+ * the C enum does not carry. */
+export const LogLevel = {
+  verbose: 0,
+  debug: 1,
+  info: 2,
+  warning: 3,
+  error: 4,
+  fatal: 5,
+  none: 6,
+} as const;
+
+export type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
+
+/** `TAppenderMode`: whether a record reaches the file before the call returns. */
+export const AppenderMode = {
+  /** The record goes into the memory-mapped cache and a writer thread takes it
+   * to the file — what the C++ opens with, and what `flush` drains. */
+  async: 0,
+  /** The record is in the file before the call returns, at a write and a lock
+   * per line. */
+  sync: 1,
+} as const;
+
+export type AppenderMode = (typeof AppenderMode)[keyof typeof AppenderMode];
+
+/** `TCompressMode`: how a log file is compressed once it is closed. */
+export const CompressMode = {
+  /** zlib, what the C++ opens with and what every reader of a mars log file
+   * understands. */
+  zlib: 0,
+  /** Zstandard: smaller at the same speed, and unreadable by a tool that only
+   * knows zlib. */
+  zstd: 1,
+} as const;
+
+export type CompressMode = (typeof CompressMode)[keyof typeof CompressMode];
+
+/** `XLogConfig` of the C++ project, in the spelling the Kotlin of the port
+ * gives it: what an `Xlog` is opened with.
+ *
+ * Every field has the default the C++'s own `XLogConfig` carries, so the one an
+ * app has to give is `logDir` — the appender answers
+ * `MARS_XLOG_ERR_EMPTY_LOG_DIR` without it. */
+export interface XlogConfig {
+  /** Where the log files are written; created if it is missing, and the one
+   * field with no default. */
+  logDir: string;
+  /** What every log file starts with (`marsrs_20260927.xlog`), and the name the
+   * appender is known by — an app that writes through two of them gives them
+   * two. `xlog` when left out. */
+  namePrefix?: string;
+  /** The level the appender is opened at; `info` when left out. */
+  level?: LogLevel;
+  /** Whether a write reaches the file before it returns. */
+  mode?: AppenderMode;
+  /** Empty means the log is written unencrypted. */
+  pubKey?: string;
+  /** How a closed log file is compressed. */
+  compressMode?: CompressMode;
+  /** `0` keeps the appender's own default (6). */
+  compressLevel?: number;
+  /** Left out, the mmap cache lives in the log directory. */
+  cacheDir?: string;
+  /** `0` keeps every file. */
+  cacheDays?: number;
+}
+
+/** `XlogConfig.namePrefix` of the Kotlin and of the Swift: what an appender is
+ * opened with when a caller gives none. */
+const DEFAULT_NAME_PREFIX = 'xlog';
+
+/** The appender of every `namePrefix` `Xlog.open` has opened and `close` has
+ * not closed, by the prefix: what makes two `Xlog.open`s of one prefix one
+ * appender, which the native side already is — one module, one appender per
+ * prefix, and every call carrying the prefix it is about.
+ *
+ * The second `open` answers the appender the first made, so the two names an
+ * app holds are one `Xlog`: `close` on either is `close` on both, and nothing
+ * writes through an appender that is gone — which is what it would do, and in
+ * silence, if the second call were a second instance the first one's `close`
+ * did not know about. */
+const openAppenders = new Map<string, Xlog>();
+
+/** The appender of one `namePrefix`: the `Xlog` of the Swift and the Kotlin of
+ * the port. `Xlog.open` makes it, and `close` releases the appender it made. */
+export class Xlog {
+  /** The name the appender is known by, and what every one of its files starts
+   * with: the `namePrefix` of the Kotlin and of the Swift. */
+  readonly namePrefix: string;
+
+  private currentLevel: LogLevel;
+
+  private currentMode: AppenderMode;
+
+  private currentConsoleLogEnabled = false;
+
+  private currentMaxFileSize = 0;
+
+  private currentMaxAliveTime = 0;
+
+  /** Whether `close` has been called on this instance. */
+  private open = true;
+
+  private constructor(config: XlogConfig) {
+    this.namePrefix = config.namePrefix ?? DEFAULT_NAME_PREFIX;
+    this.currentLevel = config.level ?? LogLevel.info;
+    this.currentMode = config.mode ?? AppenderMode.async;
+  }
+
+  /** `mars_xlog_new_instance`: opens the appender of `config` and answers the
+   * `Xlog` that writes through it.
+   *
+   * The appender of a `namePrefix` this has already opened is answered as it
+   * is, and not opened again: the native side is one appender per prefix, and a
+   * second one over the first would be a handle nothing releases. So two calls
+   * of one prefix are one `Xlog`, and `close` on it is `close` on both.
+   *
+   * Throws when the appender would not take the configuration — an empty
+   * `logDir` or `namePrefix`, or a directory it cannot write to. */
+  static open(config: XlogConfig): Xlog {
+    const namePrefix = config.namePrefix ?? DEFAULT_NAME_PREFIX;
+    const alreadyOpen = openAppenders.get(namePrefix);
+    if (alreadyOpen) {
+      return alreadyOpen;
+    }
+    const xlog = new Xlog(config);
+    if (!NativeXlog.open(config)) {
+      throw new Error(
+        `marsrs-react-native-xlog: the appender of '${xlog.namePrefix}' refused ${config.logDir}`
+      );
+    }
+    openAppenders.set(namePrefix, xlog);
+    return xlog;
+  }
+
+  /** Whether the appender is still open: `false` after `close`. */
+  get isOpen(): boolean {
+    return this.open;
+  }
+
+  /** The level of this appender: what the appender answers, and not what this
+   * instance holds — `mars_xlog_get_level`, which is the one of the five
+   * settings the C ABI has a getter for. */
+  get level(): LogLevel {
+    if (!this.open) {
+      return this.currentLevel;
+    }
+    const level = NativeXlog.getLevel(this.namePrefix) as LogLevel;
+    this.currentLevel = level;
+    return level;
+  }
+
+  set level(level: LogLevel) {
+    if (!this.open) {
+      return;
+    }
+    NativeXlog.setLevel(this.namePrefix, level);
+    this.currentLevel = level;
+  }
+
+  /** The mode of this appender: what `open` or the last write to it gave it,
+   * because the C ABI is asked for a mode and never answers one. */
+  get mode(): AppenderMode {
+    return this.currentMode;
+  }
+
+  set mode(mode: AppenderMode) {
+    if (!this.open) {
+      return;
+    }
+    NativeXlog.setMode(this.namePrefix, mode);
+    this.currentMode = mode;
+  }
+
+  /** Whether the console prints the log too: what the last write to it gave it,
+   * `false` when there was none. */
+  get consoleLogEnabled(): boolean {
+    return this.currentConsoleLogEnabled;
+  }
+
+  set consoleLogEnabled(enabled: boolean) {
+    if (!this.open) {
+      return;
+    }
+    NativeXlog.setConsoleLogEnabled(this.namePrefix, enabled);
+    this.currentConsoleLogEnabled = enabled;
+  }
+
+  /** The size a log file is split at, in bytes; `0` never splits. */
+  get maxFileSizeBytes(): number {
+    return this.currentMaxFileSize;
+  }
+
+  set maxFileSizeBytes(bytes: number) {
+    if (!this.open) {
+      return;
+    }
+    NativeXlog.setMaxFileSize(this.namePrefix, bytes);
+    this.currentMaxFileSize = bytes;
+  }
+
+  /** How long a log file is written to before the appender opens the next one,
+   * in seconds; `0` is the C++'s own ten days. */
+  get maxAliveTimeSeconds(): number {
+    return this.currentMaxAliveTime;
+  }
+
+  set maxAliveTimeSeconds(seconds: number) {
+    if (!this.open) {
+      return;
+    }
+    NativeXlog.setMaxAliveTime(this.namePrefix, seconds);
+    this.currentMaxAliveTime = seconds;
+  }
+
+  /** Whether a record at `level` is written: the appender's own answer, and the
+   * one the Swift's `isLoggable` and the Kotlin's give. An app asks it before it
+   * builds a message that is expensive to build. */
+  isLoggable(level: LogLevel): boolean {
+    if (!this.open) {
+      return false;
+    }
+    return NativeXlog.isLoggable(this.namePrefix, level);
+  }
+
+  /** `mars_xlog_write_instance`: writes `message` at `level`, tagged `tag`.
+   *
+   * The file, the function and the line of the record are left empty on the
+   * platform side — there is no JS frame to name, and the C++ writes an empty
+   * one too. */
+  log(level: LogLevel, tag: string, message: string): void {
+    if (!this.open) {
+      return;
+    }
+    NativeXlog.log(this.namePrefix, level, tag, message);
+  }
+
+  /** `log` at `LogLevel.verbose`. */
+  v(tag: string, message: string): void {
+    this.log(LogLevel.verbose, tag, message);
+  }
+
+  /** `log` at `LogLevel.debug`. */
+  d(tag: string, message: string): void {
+    this.log(LogLevel.debug, tag, message);
+  }
+
+  /** `log` at `LogLevel.info`. */
+  i(tag: string, message: string): void {
+    this.log(LogLevel.info, tag, message);
+  }
+
+  /** `log` at `LogLevel.warning`. */
+  w(tag: string, message: string): void {
+    this.log(LogLevel.warning, tag, message);
+  }
+
+  /** `log` at `LogLevel.error`. */
+  e(tag: string, message: string): void {
+    this.log(LogLevel.error, tag, message);
+  }
+
+  /** `log` at `LogLevel.fatal`. */
+  f(tag: string, message: string): void {
+    this.log(LogLevel.fatal, tag, message);
+  }
+
+  /** `mars_xlog_flush_instance`: takes what is in the cache to the file. `sync`
+   * waits for the write, which is what an app wants before it reads the file,
+   * uploads it, or lets the process go. */
+  flush(sync = false): void {
+    if (!this.open) {
+      return;
+    }
+    NativeXlog.flush(this.namePrefix, sync);
+  }
+
+  /** `mars_xlog_release_instance`: closes the appender `Xlog.open` made.
+   * Nothing is closed twice: an `Xlog` that is already closed answers `false`
+   * from `isOpen` and drops what it is asked to write — and an appender two
+   * names hold is closed for both, because `Xlog.open` gave them one `Xlog`. */
+  close(): void {
+    if (!this.open) {
+      return;
+    }
+    this.open = false;
+    openAppenders.delete(this.namePrefix);
+    NativeXlog.close(this.namePrefix);
+  }
+}
+
+export default Xlog;