@gjsify/rolldown-native 0.4.0 → 0.4.3

package/package.json

@@ -1,56 +1,56 @@
 {
-  "name": "@gjsify/rolldown-native",
-  "version": "0.4.0",
-  "description": "Phase D-2 POC: Vala/GObject + Rust cdylib bridge to rolldown for GJS. Wraps `rolldown::Bundler::generate()` (async, tokio) in a per-call current-thread runtime so JS sees a sync `bundle()` call. JSON-encoded BundlerOptions in, JSON-encoded BundleOutput out — the boundary stays small even though rolldown's option surface is enormous. POC scope: no JS plugins (Phase B), no watch/HMR, no incremental builds. Companion to `@gjsify/lightningcss-native`; together they remove the last two Rust-crate runtime blockers from the gjsify build pipeline (Phase D-3 unblock).",
-  "type": "module",
-  "main": "lib/esm/index.js",
-  "module": "lib/esm/index.js",
-  "types": "lib/types/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./lib/types/index.d.ts",
-      "default": "./lib/esm/index.js"
-    }
-  },
-  "files": [
-    "lib",
-    "prebuilds",
-    "meson.build",
-    "src/rust",
-    "src/vala"
-  ],
-  "gjsify": {
-    "prebuilds": "prebuilds"
-  },
-  "scripts": {
-    "clear": "rm -rf lib build tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo || exit 0",
-    "check": "tsc --noEmit",
-    "init:meson": "meson setup build .",
-    "init:meson:wipe": "yarn init:meson --wipe",
-    "build": "yarn build:gjsify && yarn build:types",
-    "build:gjsify": "gjsify build --library 'src/ts/**/*.{ts,js}'",
-    "build:meson": "yarn init:meson && meson compile -C build",
-    "build:types": "tsc",
-    "build:prebuilds": "yarn build:meson && mkdir -p prebuilds/linux-x86_64 && cp build/libgjsifyrolldown.so build/libgjsify_rolldown.so build/GjsifyRolldown-1.0.gir build/GjsifyRolldown-1.0.typelib prebuilds/linux-x86_64/"
-  },
-  "keywords": [
-    "gjs",
-    "rolldown",
-    "bundler",
-    "vala",
-    "rust",
-    "native"
-  ],
-  "dependencies": {
-    "@girs/gjs": "4.0.0-rc.15",
-    "@girs/glib-2.0": "2.88.0-4.0.0-rc.15",
-    "@girs/gobject-2.0": "2.88.0-4.0.0-rc.15"
-  },
-  "devDependencies": {
-    "@gjsify/cli": "^0.4.0",
-    "@types/node": "^25.6.2",
-    "typescript": "^6.0.3"
-  },
-  "author": "Pascal Garber <pascal@artandcode.studio>",
-  "license": "MIT"
-}
+    "name": "@gjsify/rolldown-native",
+    "version": "0.4.3",
+    "description": "Phase D-2 POC: Vala/GObject + Rust cdylib bridge to rolldown for GJS. Wraps `rolldown::Bundler::generate()` (async, tokio) in a per-call current-thread runtime so JS sees a sync `bundle()` call. JSON-encoded BundlerOptions in, JSON-encoded BundleOutput out — the boundary stays small even though rolldown's option surface is enormous. POC scope: no JS plugins (Phase B), no watch/HMR, no incremental builds. Companion to `@gjsify/lightningcss-native`; together they remove the last two Rust-crate runtime blockers from the gjsify build pipeline (Phase D-3 unblock).",
+    "type": "module",
+    "main": "lib/esm/index.js",
+    "module": "lib/esm/index.js",
+    "types": "lib/types/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./lib/types/index.d.ts",
+            "default": "./lib/esm/index.js"
+        }
+    },
+    "files": [
+        "lib",
+        "prebuilds",
+        "meson.build",
+        "src/rust",
+        "src/vala"
+    ],
+    "gjsify": {
+        "prebuilds": "prebuilds"
+    },
+    "scripts": {
+        "clear": "rm -rf lib build tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo || exit 0",
+        "check": "tsc --noEmit",
+        "init:meson": "meson setup build .",
+        "init:meson:wipe": "gjsify run init:meson --wipe",
+        "build": "gjsify run build:gjsify && gjsify run build:types",
+        "build:gjsify": "gjsify build --library 'src/ts/**/*.{ts,js}'",
+        "build:meson": "gjsify run init:meson && meson compile -C build",
+        "build:types": "tsc",
+        "build:prebuilds": "gjsify run build:meson && mkdir -p prebuilds/linux-x86_64 && cp build/libgjsifyrolldown.so build/libgjsify_rolldown.so build/GjsifyRolldown-1.0.gir build/GjsifyRolldown-1.0.typelib prebuilds/linux-x86_64/"
+    },
+    "keywords": [
+        "gjs",
+        "rolldown",
+        "bundler",
+        "vala",
+        "rust",
+        "native"
+    ],
+    "dependencies": {
+        "@girs/gjs": "4.0.0-rc.15",
+        "@girs/glib-2.0": "2.88.0-4.0.0-rc.15",
+        "@girs/gobject-2.0": "2.88.0-4.0.0-rc.15"
+    },
+    "devDependencies": {
+        "@gjsify/cli": "workspace:^",
+        "@types/node": "^25.6.2",
+        "typescript": "^6.0.3"
+    },
+    "author": "Pascal Garber <pascal@artandcode.studio>",
+    "license": "MIT"
+}

package/src/rust/Cargo.toml

@@ -0,0 +1,37 @@
+[package]
+name = "gjsify_rolldown"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+# NOTE on dependency resolution
+# ─────────────────────────────
+# rolldown 0.1.0 on crates.io ships with transitive workspace deps that
+# don't compile cleanly together (rolldown_fs depends on a newer
+# OxcResolverFileSystem trait surface than the published rolldown_resolver
+# can satisfy — `error E0046: missing read, canonicalize`). Until that
+# coherence problem is fixed upstream, we build against the in-tree
+# refs/rolldown submodule via path deps. This means contributors need
+# `git submodule update --init refs/rolldown` to build the cdylib from
+# source — but downstream npm consumers only ever consume the prebuilt
+# .so + .typelib in `prebuilds/`, so they never see the submodule.
+[dependencies]
+rolldown = { path = "../../../../../refs/rolldown/crates/rolldown", features = ["serde"] }
+rolldown_common = { path = "../../../../../refs/rolldown/crates/rolldown_common", features = ["deserialize_bundler_options"] }
+rolldown_plugin = { path = "../../../../../refs/rolldown/crates/rolldown_plugin" }
+anyhow = "1"
+async-trait = "0.1"
+crossbeam-channel = "0.5"
+libc = "0.2"
+regex = "1"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+tokio = { version = "1", features = ["rt", "rt-multi-thread", "macros", "sync", "time"] }
+
+[profile.release]
+lto = "thin"
+codegen-units = 1
+strip = true

package/src/rust/src/lib.rs

@@ -0,0 +1,224 @@
+//! gjsify_rolldown — single-call Rust→C FFI for the rolldown bundler.
+//!
+//! Phase D-2 POC. Mirrors the @gjsify/lightningcss-native pattern:
+//! one `extern "C"` entry point that takes a JSON-encoded options blob
+//! and returns either a JSON-encoded BundleOutput or a heap-allocated
+//! error message. The C glue layer (src/vala/gjsify-rolldown-glue.c)
+//! turns those into GBytes + GError; the Vala wrapper (src/vala/rolldown.vala)
+//! exposes a GObject method.
+//!
+//! Why JSON for both directions?
+//!   - rolldown's BundlerOptions has dozens of nested types with custom
+//!     serde deserializers (browserslist, treeshake, code-splitting…);
+//!     a flat C struct hand-binding would be many hundreds of lines and
+//!     would drift each rolldown release. JSON keeps the boundary tiny.
+//!   - The output side has the same problem (warnings, source maps,
+//!     module dependency graph). Re-using rolldown's serde shape means
+//!     gjsify-side TS code can lean on the exact same JSON the
+//!     @rolldown/binding-wasm32-wasi loader emits for Node consumers.
+//!
+//! POC scope: no JS plugins, no watch mode, no incremental builds. Each
+//! call constructs a fresh Bundler, runs `generate()` on a per-call
+//! current-thread tokio runtime, and returns. This keeps the boundary
+//! sync from the JS view (what GJS expects) at the cost of losing
+//! parallel rolldown plugin workers — fine for the POC, addressed in
+//! Phase B alongside JS plugin support.
+
+#![allow(clippy::not_unsafe_ptr_arg_deref)]
+
+use std::ffi::CString;
+use std::os::raw::c_char;
+use std::ptr;
+
+use rolldown::Bundler;
+use rolldown_common::BundlerOptions;
+use serde::Serialize;
+use tokio::runtime::Builder;
+
+// Plugin-callback machinery (Phase B.1). The session module owns the
+// stateful Bundler instance + tokio runtime + Vala-side eventfd
+// pumps; plugin_proxy holds the JsPluginProxy that bridges
+// rolldown's Pluginable trait to the channel.
+pub mod plugin_proxy;
+pub mod session;
+
+/// Serializable mirror of the parts of `rolldown_common::Output` we expose to JS.
+///
+/// Both the variant tag (`Chunk`/`Asset` → `chunk`/`asset`) and the per-variant
+/// field names are camelCased so JS sees `{type:"chunk", fileName:"…"}`.
+#[derive(Serialize)]
+#[serde(tag = "type", rename_all = "camelCase")]
+pub enum OutputJson {
+    #[serde(rename_all = "camelCase")]
+    Chunk {
+        file_name: String,
+        name: String,
+        is_entry: bool,
+        is_dynamic_entry: bool,
+        code: String,
+        map: Option<String>,
+        sourcemap_filename: Option<String>,
+        imports: Vec<String>,
+        dynamic_imports: Vec<String>,
+    },
+    #[serde(rename_all = "camelCase")]
+    Asset {
+        file_name: String,
+        names: Vec<String>,
+        original_file_names: Vec<String>,
+        source_text: Option<String>,
+        source_bytes_len: usize,
+    },
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BundleOutputJson {
+    pub warnings: Vec<String>,
+    pub output: Vec<OutputJson>,
+}
+
+/// Result of `gjsify_rolldown_bundle`.
+///
+/// On success: `output` points at a heap-allocated NUL-terminated UTF-8
+/// JSON document of `BundleOutputJson`; `error` is NULL.
+/// On error: `output` is NULL; `error` points at a heap-allocated
+/// NUL-terminated UTF-8 message.
+///
+/// Caller MUST pass the returned struct to
+/// `gjsify_rolldown_result_free` exactly once.
+#[repr(C)]
+pub struct GjsifyRolldownResult {
+    pub output: *mut c_char,
+    pub output_len: usize,
+    pub error: *mut c_char,
+}
+
+impl GjsifyRolldownResult {
+    fn empty() -> Self {
+        Self { output: ptr::null_mut(), output_len: 0, error: ptr::null_mut() }
+    }
+
+    fn err(msg: impl Into<String>) -> Self {
+        let mut r = Self::empty();
+        let cstr = CString::new(msg.into()).unwrap_or_else(|_| {
+            CString::new("rolldown: error message contained interior NUL").unwrap()
+        });
+        r.error = cstr.into_raw();
+        r
+    }
+
+    fn ok(json: String) -> Self {
+        let len = json.len();
+        let cstr = match CString::new(json) {
+            Ok(c) => c,
+            Err(_) => return Self::err("rolldown: output JSON contained interior NUL"),
+        };
+        Self { output: cstr.into_raw(), output_len: len, error: ptr::null_mut() }
+    }
+}
+
+pub fn convert_output(out: rolldown_common::Output) -> OutputJson {
+    use rolldown_common::Output;
+    match out {
+        Output::Chunk(chunk) => {
+            let map_str = chunk.map.as_ref().map(|m| m.to_json_string());
+            OutputJson::Chunk {
+                file_name: chunk.filename.to_string(),
+                name: chunk.name.to_string(),
+                is_entry: chunk.is_entry,
+                is_dynamic_entry: chunk.is_dynamic_entry,
+                code: chunk.code.clone(),
+                map: map_str,
+                sourcemap_filename: chunk.sourcemap_filename.clone(),
+                imports: chunk.imports.iter().map(|s| s.to_string()).collect(),
+                dynamic_imports: chunk.dynamic_imports.iter().map(|s| s.to_string()).collect(),
+            }
+        }
+        Output::Asset(asset) => {
+            let bytes = asset.source.as_bytes();
+            // Try to expose UTF-8 assets as text; fall back to byte-length only
+            // for binary assets (PNG etc). Binary content can be read via the
+            // emitted file when output.dir is set.
+            let source_text = std::str::from_utf8(bytes).ok().map(str::to_owned);
+            OutputJson::Asset {
+                file_name: asset.filename.to_string(),
+                names: asset.names.clone(),
+                original_file_names: asset.original_file_names.clone(),
+                source_text,
+                source_bytes_len: bytes.len(),
+            }
+        }
+    }
+}
+
+/// Bundle a JS project. `options_json` is a NUL-terminated UTF-8 JSON
+/// document matching rolldown's `BundlerOptions` serde shape (camelCase).
+///
+/// Memory: the input pointer is borrowed; the returned struct owns its
+/// allocations and must be released via `gjsify_rolldown_result_free`.
+#[unsafe(no_mangle)]
+pub extern "C" fn gjsify_rolldown_bundle(
+    options_json: *const c_char,
+    options_json_len: usize,
+) -> GjsifyRolldownResult {
+    if options_json.is_null() || options_json_len == 0 {
+        return GjsifyRolldownResult::err("rolldown: empty options JSON");
+    }
+
+    let json_slice = unsafe { std::slice::from_raw_parts(options_json as *const u8, options_json_len) };
+    let json_str = match std::str::from_utf8(json_slice) {
+        Ok(s) => s,
+        Err(_) => return GjsifyRolldownResult::err("rolldown: invalid UTF-8 in options JSON"),
+    };
+
+    let opts: BundlerOptions = match serde_json::from_str(json_str) {
+        Ok(o) => o,
+        Err(e) => return GjsifyRolldownResult::err(format!("rolldown: options parse: {e}")),
+    };
+
+    // Per-call current-thread tokio runtime: lets GJS exit cleanly, no
+    // background workers leak after bundle() returns. Phase B can move
+    // to a long-lived runtime for plugin-callback support.
+    let rt = match Builder::new_current_thread().enable_all().build() {
+        Ok(r) => r,
+        Err(e) => return GjsifyRolldownResult::err(format!("rolldown: tokio init: {e}")),
+    };
+
+    let bundle_result = rt.block_on(async {
+        let mut bundler = Bundler::new(opts).map_err(|e| format!("Bundler::new: {e:?}"))?;
+        bundler.generate().await.map_err(|e| format!("Bundler::generate: {e:?}"))
+    });
+
+    let bundle = match bundle_result {
+        Ok(b) => b,
+        Err(msg) => return GjsifyRolldownResult::err(format!("rolldown: {msg}")),
+    };
+
+    let warnings: Vec<String> = bundle.warnings.iter().map(|w| format!("{w:?}")).collect();
+    let output: Vec<OutputJson> = bundle
+        .assets
+        .into_iter()
+        .map(convert_output)
+        .collect();
+
+    let json = match serde_json::to_string(&BundleOutputJson { warnings, output }) {
+        Ok(s) => s,
+        Err(e) => return GjsifyRolldownResult::err(format!("rolldown: serialize: {e}")),
+    };
+
+    GjsifyRolldownResult::ok(json)
+}
+
+/// Free the buffers owned by a `GjsifyRolldownResult`. Safe to call on
+/// either an OK result (frees `output`) or an error result (frees
+/// `error`). Must NOT be called twice on the same struct.
+#[unsafe(no_mangle)]
+pub extern "C" fn gjsify_rolldown_result_free(result: GjsifyRolldownResult) {
+    if !result.output.is_null() {
+        unsafe { drop(CString::from_raw(result.output)) };
+    }
+    if !result.error.is_null() {
+        unsafe { drop(CString::from_raw(result.error)) };
+    }
+}