@gjsify/lightningcss-native 0.4.0 → 0.4.4

package/package.json

@@ -1,60 +1,60 @@
 {
-  "name": "@gjsify/lightningcss-native",
-  "version": "0.4.0",
-  "description": "Vala/GObject + Rust cdylib bridge to lightningcss for GJS. Replaces the Node-only npm `lightningcss` package: parse, transform, minify, and browserslist-target lowering of CSS without leaving a Node-free GJS process. Backs `@gjsify/rolldown-plugin-gjsify`'s cssAsStringPlugin under `--app gjs` so GTK4-CSS lowering (firefox60) works without a Node runtime in the build pipeline.",
-  "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/libgjsifylightningcss.so build/libgjsify_lightningcss.so build/GjsifyLightningcss-1.0.gir build/GjsifyLightningcss-1.0.typelib prebuilds/linux-x86_64/",
-    "build:gir-types": "ts-for-gir generate --externalDeps --allowMissingDeps --girDirectories=./prebuilds/linux-x86_64 --girDirectories=/usr/share/gir-1.0 --modules=GjsifyLightningcss-1.0 --outdir=src/ts --npmScope=@girs --package=false --ignoreVersionConflicts=true"
-  },
-  "keywords": [
-    "gjs",
-    "lightningcss",
-    "css",
-    "minify",
-    "browserslist",
-    "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",
-    "@ts-for-gir/cli": "^4.0.0-rc.15",
-    "@types/node": "^25.6.2",
-    "typescript": "^6.0.3"
-  },
-  "author": "Pascal Garber <pascal@artandcode.studio>",
-  "license": "MIT"
-}
+    "name": "@gjsify/lightningcss-native",
+    "version": "0.4.4",
+    "description": "Vala/GObject + Rust cdylib bridge to lightningcss for GJS. Replaces the Node-only npm `lightningcss` package: parse, transform, minify, and browserslist-target lowering of CSS without leaving a Node-free GJS process. Backs `@gjsify/rolldown-plugin-gjsify`'s cssAsStringPlugin under `--app gjs` so GTK4-CSS lowering (firefox60) works without a Node runtime in the build pipeline.",
+    "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/libgjsifylightningcss.so build/libgjsify_lightningcss.so build/GjsifyLightningcss-1.0.gir build/GjsifyLightningcss-1.0.typelib prebuilds/linux-x86_64/",
+        "build:gir-types": "ts-for-gir generate --externalDeps --allowMissingDeps --girDirectories=./prebuilds/linux-x86_64 --girDirectories=/usr/share/gir-1.0 --modules=GjsifyLightningcss-1.0 --outdir=src/ts --npmScope=@girs --package=false --ignoreVersionConflicts=true"
+    },
+    "keywords": [
+        "gjs",
+        "lightningcss",
+        "css",
+        "minify",
+        "browserslist",
+        "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.4",
+        "@ts-for-gir/cli": "^4.0.0-rc.15",
+        "@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,18 @@
+[package]
+name = "gjsify_lightningcss"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+lightningcss = { version = "1.0.0-alpha.71", features = ["browserslist"] }
+parcel_sourcemap = { version = "2.1.1", features = ["json"] }
+browserslist-rs = { version = "0.19.0" }
+
+[profile.release]
+lto = true
+codegen-units = 1
+strip = true

package/src/rust/src/lib.rs

@@ -0,0 +1,330 @@
+//! gjsify_lightningcss — single-call Rust→C FFI for lightningcss.
+//!
+//! Adapted from refs/lightningcss/c/src/lib.rs (lightningcss_c_bindings,
+//! Devon Govett, MIT). The upstream C bindings expose a 3-step pipeline
+//! (parse → transform → to_css) plus separate Targets/PseudoClasses/etc
+//! structs, which is more surface area than the Vala bridge needs.
+//!
+//! This crate collapses the warm-up POC's surface to a single call:
+//!     gjsify_lightningcss_transform(opts) -> GjsifyResult
+//! with browserslist resolved internally and the result owning all buffer
+//! allocations until gjsify_lightningcss_result_free() is called.
+//!
+//! Modifications: combined pipeline, browserslist-as-string in the same
+//! call, simplified result struct, no css-modules / no analyze-dependencies
+//! / no pseudo-class rewrites. Those can be added back if Phase B needs
+//! them.
+
+#![allow(clippy::not_unsafe_ptr_arg_deref)]
+
+use std::ffi::{CStr, CString};
+use std::os::raw::c_char;
+use std::ptr;
+
+use lightningcss::bundler::{Bundler, FileProvider};
+use lightningcss::stylesheet::{
+    MinifyOptions, ParserFlags, ParserOptions, PrinterOptions, StyleSheet,
+};
+use lightningcss::targets::{Browsers, Targets};
+use parcel_sourcemap::SourceMap;
+
+#[repr(C)]
+pub struct GjsifyTransformOpts {
+    pub filename: *const c_char,         // may be NULL → ""
+    pub code: *const u8,
+    pub code_len: usize,
+    pub browserslist: *const c_char,     // may be NULL → no targets
+    pub minify: bool,
+    pub source_map: bool,
+}
+
+/// Result of a transform. On success `error` is NULL; otherwise `code`/`map`
+/// are NULL and `error` points at a NUL-terminated UTF-8 message.
+///
+/// All non-NULL pointers were allocated on the Rust side and MUST be freed
+/// via `gjsify_lightningcss_result_free` — never with libc free().
+#[repr(C)]
+pub struct GjsifyResult {
+    pub code: *mut u8,
+    pub code_len: usize,
+    pub code_cap: usize,
+    pub map: *mut u8,
+    pub map_len: usize,
+    pub map_cap: usize,
+    pub error: *mut c_char,
+}
+
+impl GjsifyResult {
+    fn empty() -> Self {
+        GjsifyResult {
+            code: ptr::null_mut(),
+            code_len: 0,
+            code_cap: 0,
+            map: ptr::null_mut(),
+            map_len: 0,
+            map_cap: 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("lightningcss: error message contained interior NUL byte").unwrap()
+        });
+        r.error = cstr.into_raw();
+        r
+    }
+}
+
+fn cstr_to_str<'a>(p: *const c_char) -> Option<&'a str> {
+    if p.is_null() {
+        None
+    } else {
+        unsafe { CStr::from_ptr(p) }.to_str().ok()
+    }
+}
+
+fn vec_to_owned_ptr(mut v: Vec<u8>) -> (*mut u8, usize, usize) {
+    let ptr = v.as_mut_ptr();
+    let len = v.len();
+    let cap = v.capacity();
+    std::mem::forget(v);
+    (ptr, len, cap)
+}
+
+/// One-shot CSS transform.
+///
+/// Steps internally: parse → resolve browserslist (if any) → minify (with
+/// optional targets lowering) → print to CSS string + source map.
+///
+/// Returns a `GjsifyResult`. Caller MUST pass the result to
+/// `gjsify_lightningcss_result_free` exactly once to release buffers.
+#[no_mangle]
+pub extern "C" fn gjsify_lightningcss_transform(opts: GjsifyTransformOpts) -> GjsifyResult {
+    if opts.code.is_null() || opts.code_len == 0 {
+        return GjsifyResult::err("lightningcss: empty input CSS");
+    }
+    let code = {
+        let slice = unsafe { std::slice::from_raw_parts(opts.code, opts.code_len) };
+        match std::str::from_utf8(slice) {
+            Ok(s) => s,
+            Err(_) => return GjsifyResult::err("lightningcss: invalid UTF-8 in input CSS"),
+        }
+    };
+
+    let filename = cstr_to_str(opts.filename).unwrap_or("").to_owned();
+
+    // Resolve browserslist → Targets (if requested).
+    let targets: Targets = match cstr_to_str(opts.browserslist) {
+        None => Targets::default(),
+        Some(query) => match Browsers::from_browserslist([query]) {
+            Ok(Some(browsers)) => Targets::from(browsers),
+            Ok(None) => Targets::default(),
+            Err(e) => {
+                return GjsifyResult::err(format!("lightningcss: browserslist: {e}"))
+            }
+        },
+    };
+
+    let parser_opts = ParserOptions {
+        filename: filename.clone(),
+        flags: ParserFlags::empty(),
+        css_modules: None,
+        error_recovery: false,
+        source_index: 0,
+        warnings: None,
+    };
+
+    let mut stylesheet = match StyleSheet::parse(code, parser_opts) {
+        Ok(ss) => ss,
+        Err(e) => return GjsifyResult::err(format!("lightningcss: parse: {e}")),
+    };
+
+    // minify() must run regardless of options.minify — it's where the
+    // targets-driven lowering (nesting flatten, vendor prefixes, …) happens.
+    let minify_opts = MinifyOptions {
+        targets,
+        ..Default::default()
+    };
+    if let Err(e) = stylesheet.minify(minify_opts) {
+        return GjsifyResult::err(format!("lightningcss: transform: {e}"));
+    }
+
+    // Optional source map.
+    let mut source_map = if opts.source_map {
+        let mut sm = SourceMap::new("/");
+        let src_name = if filename.is_empty() { "input.css".to_owned() } else { filename.clone() };
+        sm.add_source(&src_name);
+        if let Err(e) = sm.set_source_content(0, code) {
+            return GjsifyResult::err(format!("lightningcss: source-map: {e}"));
+        }
+        Some(sm)
+    } else {
+        None
+    };
+
+    let printer_opts = PrinterOptions {
+        minify: opts.minify,
+        project_root: None,
+        source_map: source_map.as_mut(),
+        targets,
+        analyze_dependencies: None,
+        pseudo_classes: None,
+    };
+
+    let printed = match stylesheet.to_css(printer_opts) {
+        Ok(p) => p,
+        Err(e) => return GjsifyResult::err(format!("lightningcss: print: {e}")),
+    };
+
+    let (code_ptr, code_len, code_cap) = vec_to_owned_ptr(printed.code.into_bytes());
+
+    let (map_ptr, map_len, map_cap) = if let Some(mut sm) = source_map {
+        match sm.to_json(None) {
+            Ok(json) => vec_to_owned_ptr(json.into_bytes()),
+            Err(e) => {
+                // free code we just allocated
+                unsafe { Vec::from_raw_parts(code_ptr, code_len, code_cap) };
+                return GjsifyResult::err(format!("lightningcss: source-map serialize: {e}"));
+            }
+        }
+    } else {
+        (ptr::null_mut(), 0, 0)
+    };
+
+    GjsifyResult {
+        code: code_ptr,
+        code_len,
+        code_cap,
+        map: map_ptr,
+        map_len,
+        map_cap,
+        error: ptr::null_mut(),
+    }
+}
+
+/// Free the buffers owned by a `GjsifyResult`. Safe to call on a result
+/// where `error` is set (only the error CString is freed in that case).
+/// Safe to call on a zeroed/empty result.
+#[no_mangle]
+pub extern "C" fn gjsify_lightningcss_result_free(result: GjsifyResult) {
+    if !result.code.is_null() {
+        unsafe { drop(Vec::from_raw_parts(result.code, result.code_len, result.code_cap)) };
+    }
+    if !result.map.is_null() {
+        unsafe { drop(Vec::from_raw_parts(result.map, result.map_len, result.map_cap)) };
+    }
+    if !result.error.is_null() {
+        unsafe { drop(CString::from_raw(result.error)) };
+    }
+}
+
+#[repr(C)]
+pub struct GjsifyBundleOpts {
+    pub filename: *const c_char,         // entry CSS path; must NOT be NULL
+    pub browserslist: *const c_char,     // may be NULL → no targets
+    pub minify: bool,
+    pub source_map: bool,
+    pub error_recovery: bool,
+}
+
+/// Bundle a CSS entry file: resolve all `@import` chains via the
+/// lightningcss `Bundler` + `FileProvider` (filesystem-backed), then
+/// run the same minify/transform/print pipeline as `transform()`.
+///
+/// Same `GjsifyResult` ownership rules as `gjsify_lightningcss_transform`.
+#[no_mangle]
+pub extern "C" fn gjsify_lightningcss_bundle(opts: GjsifyBundleOpts) -> GjsifyResult {
+    let filename = match cstr_to_str(opts.filename) {
+        Some(f) if !f.is_empty() => f.to_owned(),
+        _ => return GjsifyResult::err("lightningcss: bundle requires a non-empty filename"),
+    };
+
+    let targets: Targets = match cstr_to_str(opts.browserslist) {
+        None => Targets::default(),
+        Some(query) => match Browsers::from_browserslist([query]) {
+            Ok(Some(browsers)) => Targets::from(browsers),
+            Ok(None) => Targets::default(),
+            Err(e) => {
+                return GjsifyResult::err(format!("lightningcss: browserslist: {e}"))
+            }
+        },
+    };
+
+    let parser_opts = ParserOptions {
+        filename: filename.clone(),
+        flags: ParserFlags::empty(),
+        css_modules: None,
+        error_recovery: opts.error_recovery,
+        source_index: 0,
+        warnings: None,
+    };
+
+    let fs = FileProvider::new();
+    let mut bundler = Bundler::new(&fs, None, parser_opts);
+    let mut stylesheet = match bundler.bundle(std::path::Path::new(&filename)) {
+        Ok(ss) => ss,
+        Err(e) => return GjsifyResult::err(format!("lightningcss: bundle: {e}")),
+    };
+
+    let minify_opts = MinifyOptions {
+        targets,
+        ..Default::default()
+    };
+    if let Err(e) = stylesheet.minify(minify_opts) {
+        return GjsifyResult::err(format!("lightningcss: transform: {e}"));
+    }
+
+    let mut source_map = if opts.source_map {
+        let mut sm = SourceMap::new("/");
+        sm.add_source(&filename);
+        // Best effort: read the entry file content so the map has something
+        // sensible to point at. Bundled imports won't have their content
+        // captured; that's acceptable for the GJS lower path.
+        if let Ok(src) = std::fs::read_to_string(&filename) {
+            let _ = sm.set_source_content(0, &src);
+        }
+        Some(sm)
+    } else {
+        None
+    };
+
+    let printer_opts = PrinterOptions {
+        minify: opts.minify,
+        project_root: None,
+        source_map: source_map.as_mut(),
+        targets,
+        analyze_dependencies: None,
+        pseudo_classes: None,
+    };
+
+    let printed = match stylesheet.to_css(printer_opts) {
+        Ok(p) => p,
+        Err(e) => return GjsifyResult::err(format!("lightningcss: print: {e}")),
+    };
+
+    let (code_ptr, code_len, code_cap) = vec_to_owned_ptr(printed.code.into_bytes());
+
+    let (map_ptr, map_len, map_cap) = if let Some(mut sm) = source_map {
+        match sm.to_json(None) {
+            Ok(json) => vec_to_owned_ptr(json.into_bytes()),
+            Err(e) => {
+                unsafe { Vec::from_raw_parts(code_ptr, code_len, code_cap) };
+                return GjsifyResult::err(format!("lightningcss: source-map serialize: {e}"));
+            }
+        }
+    } else {
+        (ptr::null_mut(), 0, 0)
+    };
+
+    GjsifyResult {
+        code: code_ptr,
+        code_len,
+        code_cap,
+        map: map_ptr,
+        map_len,
+        map_cap,
+        error: ptr::null_mut(),
+    }
+}

package/src/vala/gjsify-lightningcss-glue.c

@@ -0,0 +1,117 @@
+/*
+ * GLib-friendly glue for gjsify_lightningcss. See gjsify-lightningcss-glue.h.
+ */
+
+#include "gjsify-lightningcss-glue.h"
+#include <string.h>
+
+GQuark
+gjsify_lightningcss_error_quark (void)
+{
+  return g_quark_from_static_string ("gjsify-lightningcss-error-quark");
+}
+
+GBytes *
+gjsify_lightningcss_glue_transform (const char  *filename,
+                                    GBytes      *code,
+                                    const char  *browserslist,
+                                    gboolean     minify,
+                                    gboolean     source_map,
+                                    GBytes     **out_map,
+                                    GError     **error)
+{
+  if (out_map)
+    *out_map = NULL;
+
+  if (code == NULL)
+    {
+      g_set_error_literal (error,
+                           GJSIFY_LIGHTNINGCSS_ERROR,
+                           GJSIFY_LIGHTNINGCSS_ERROR_FAILED,
+                           "lightningcss: NULL input bytes");
+      return NULL;
+    }
+
+  gsize code_len = 0;
+  const guint8 *code_data = g_bytes_get_data (code, &code_len);
+
+  GjsifyTransformOpts opts;
+  opts.filename     = filename;
+  opts.code         = code_data;
+  opts.code_len     = code_len;
+  opts.browserslist = browserslist;
+  opts.minify       = minify ? true : false;
+  opts.source_map   = source_map ? true : false;
+
+  GjsifyResult res = gjsify_lightningcss_transform (opts);
+
+  if (res.error != NULL)
+    {
+      g_set_error_literal (error,
+                           GJSIFY_LIGHTNINGCSS_ERROR,
+                           GJSIFY_LIGHTNINGCSS_ERROR_FAILED,
+                           res.error);
+      gjsify_lightningcss_result_free (res);
+      return NULL;
+    }
+
+  /* Copy Rust-allocated buffers into GBytes (GLib heap), then free the
+   * Rust result. Could be optimized later by giving GBytes a destroy
+   * notify that calls gjsify_lightningcss_result_free, but copying keeps
+   * the boundary clean and the buffers are typically small. */
+  GBytes *out_code = g_bytes_new (res.code, res.code_len);
+
+  if (source_map && res.map != NULL && out_map != NULL)
+    *out_map = g_bytes_new (res.map, res.map_len);
+
+  gjsify_lightningcss_result_free (res);
+  return out_code;
+}
+
+GBytes *
+gjsify_lightningcss_glue_bundle (const char  *filename,
+                                 const char  *browserslist,
+                                 gboolean     minify,
+                                 gboolean     source_map,
+                                 gboolean     error_recovery,
+                                 GBytes     **out_map,
+                                 GError     **error)
+{
+  if (out_map)
+    *out_map = NULL;
+
+  if (filename == NULL || filename[0] == '\0')
+    {
+      g_set_error_literal (error,
+                           GJSIFY_LIGHTNINGCSS_ERROR,
+                           GJSIFY_LIGHTNINGCSS_ERROR_FAILED,
+                           "lightningcss: bundle requires a filename");
+      return NULL;
+    }
+
+  GjsifyBundleOpts opts;
+  opts.filename       = filename;
+  opts.browserslist   = browserslist;
+  opts.minify         = minify ? true : false;
+  opts.source_map     = source_map ? true : false;
+  opts.error_recovery = error_recovery ? true : false;
+
+  GjsifyResult res = gjsify_lightningcss_bundle (opts);
+
+  if (res.error != NULL)
+    {
+      g_set_error_literal (error,
+                           GJSIFY_LIGHTNINGCSS_ERROR,
+                           GJSIFY_LIGHTNINGCSS_ERROR_FAILED,
+                           res.error);
+      gjsify_lightningcss_result_free (res);
+      return NULL;
+    }
+
+  GBytes *out_code = g_bytes_new (res.code, res.code_len);
+  if (source_map && res.map != NULL && out_map != NULL)
+    *out_map = g_bytes_new (res.map, res.map_len);
+
+  gjsify_lightningcss_result_free (res);
+  return out_code;
+}

package/src/vala/gjsify-lightningcss-glue.h

@@ -0,0 +1,73 @@
+/*
+ * GLib-friendly wrapper around the Rust transform shim.
+ *
+ * The Rust side returns its own struct with malloc'd buffers. This glue
+ * layer copies those buffers into GBytes (so GLib's refcount controls
+ * lifetime — friendly to SpiderMonkey GC) and frees the Rust result
+ * immediately. Errors become GError on the GJSIFY_LIGHTNINGCSS quark.
+ */
+
+#ifndef GJSIFY_LIGHTNINGCSS_GLUE_H
+#define GJSIFY_LIGHTNINGCSS_GLUE_H
+
+#include <glib.h>
+#include <stdbool.h>
+#include "gjsify-lightningcss.h"
+
+G_BEGIN_DECLS
+
+#define GJSIFY_LIGHTNINGCSS_ERROR (gjsify_lightningcss_error_quark ())
+
+typedef enum {
+  GJSIFY_LIGHTNINGCSS_ERROR_FAILED = 0,
+} GjsifyLightningcssError;
+
+GQuark gjsify_lightningcss_error_quark (void);
+
+/**
+ * gjsify_lightningcss_glue_transform:
+ * @filename:      logical filename for diagnostics (NULL OK)
+ * @code:          input CSS bytes
+ * @browserslist:  browserslist query (NULL = no targets lowering)
+ * @minify:        TRUE to minify the output
+ * @source_map:    TRUE to also compute a source map
+ * @out_map:       (out)(transfer full)(nullable): JSON source map, set
+ *                 only when @source_map is TRUE
+ * @error:         (out)(optional): GError on failure
+ *
+ * Returns: (transfer full): output CSS as GBytes, or NULL on error.
+ */
+GBytes *gjsify_lightningcss_glue_transform (const char  *filename,
+                                            GBytes      *code,
+                                            const char  *browserslist,
+                                            gboolean     minify,
+                                            gboolean     source_map,
+                                            GBytes     **out_map,
+                                            GError     **error);
+
+/**
+ * gjsify_lightningcss_glue_bundle:
+ * @filename:        entry CSS path (must not be NULL)
+ * @browserslist:    targets query (NULL = no lowering)
+ * @minify:          minify the output
+ * @source_map:      compute a source map for the entry file
+ * @error_recovery:  continue on parse errors (lightningcss
+ *                   `errorRecovery: true` semantics)
+ * @out_map:         (out)(transfer full)(nullable): JSON source map
+ * @error:           (out)(optional)
+ *
+ * Returns: (transfer full): bundled output CSS as GBytes. The bundler
+ * resolves @import chains via lightningcss's built-in `FileProvider`
+ * (filesystem-backed).
+ */
+GBytes *gjsify_lightningcss_glue_bundle (const char  *filename,
+                                         const char  *browserslist,
+                                         gboolean     minify,
+                                         gboolean     source_map,
+                                         gboolean     error_recovery,
+                                         GBytes     **out_map,
+                                         GError     **error);
+
+G_END_DECLS
+
+#endif /* GJSIFY_LIGHTNINGCSS_GLUE_H */

package/src/vala/gjsify-lightningcss.h

@@ -0,0 +1,60 @@
+/*
+ * Hand-written C header matching the Rust extern "C" surface of
+ * the gjsify_lightningcss cdylib (src/rust/src/lib.rs).
+ *
+ * Vala includes this via [CCode (cheader_filename = "gjsify-lightningcss.h")]
+ * to call into the Rust shim. We do NOT use cbindgen at build time —
+ * the surface is small enough that a hand-maintained header is simpler
+ * and avoids pulling cbindgen into the meson build.
+ */
+
+#ifndef GJSIFY_LIGHTNINGCSS_H
+#define GJSIFY_LIGHTNINGCSS_H
+
+#include <glib.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+G_BEGIN_DECLS
+
+typedef struct {
+  const char     *filename;       /* may be NULL → "" */
+  const uint8_t  *code;
+  size_t          code_len;
+  const char     *browserslist;   /* may be NULL → no targets lowering */
+  bool            minify;
+  bool            source_map;
+} GjsifyTransformOpts;
+
+typedef struct {
+  uint8_t   *code;
+  size_t     code_len;
+  size_t     code_cap;
+  uint8_t   *map;        /* NULL if source_map was false */
+  size_t     map_len;
+  size_t     map_cap;
+  char      *error;      /* NULL on success */
+} GjsifyResult;
+
+/* One-shot CSS transform. The returned struct owns its buffers — pass it
+ * to gjsify_lightningcss_result_free() exactly once when done. */
+GjsifyResult gjsify_lightningcss_transform (GjsifyTransformOpts opts);
+
+typedef struct {
+  const char *filename;       /* entry CSS path; MUST NOT be NULL */
+  const char *browserslist;   /* may be NULL → no targets lowering */
+  bool        minify;
+  bool        source_map;
+  bool        error_recovery;
+} GjsifyBundleOpts;
+
+/* Bundle a CSS entry file (resolves @import chains via lightningcss's
+ * built-in FileProvider). Same ownership rules as transform(). */
+GjsifyResult gjsify_lightningcss_bundle (GjsifyBundleOpts opts);
+
+void gjsify_lightningcss_result_free (GjsifyResult result);
+
+G_END_DECLS
+
+#endif /* GJSIFY_LIGHTNINGCSS_H */

package/src/vala/lightningcss.vala

@@ -0,0 +1,111 @@
+/*
+ * GjsifyLightningcss — Vala wrapper around the Rust lightningcss cdylib.
+ *
+ * The real CSS pipeline lives in src/rust/ (compiled by meson via cargo
+ * to libgjsify_lightningcss.so) and a tiny C glue file
+ * (gjsify-lightningcss-glue.{h,c}) translates the malloc'd Rust struct
+ * into GBytes + GError, which GJS handles natively.
+ *
+ * This Vala layer just exposes the GLib-friendly glue function as a
+ * GObject method that emits to GIR/typelib, so JS can do:
+ *
+ *     import GjsifyLightningcss from "gi://GjsifyLightningcss?version=1.0";
+ *     const engine = new GjsifyLightningcss.Engine();
+ *     const code = engine.transform("app.css", input, null, true, false, out null);
+ *
+ * Pattern: same as @gjsify/http2-native — Rust/C ownership stays in
+ * native land via GLib.Bytes; SpiderMonkey only sees refcounted handles.
+ */
+
+namespace GjsifyLightningcss {
+
+    [CCode (cname = "gjsify_lightningcss_glue_transform",
+            cheader_filename = "gjsify-lightningcss-glue.h")]
+    private extern GLib.Bytes? _glue_transform (string? filename,
+                                                GLib.Bytes code,
+                                                string? browserslist,
+                                                bool minify,
+                                                bool source_map,
+                                                out GLib.Bytes? out_map) throws GLib.Error;
+
+    [CCode (cname = "gjsify_lightningcss_glue_bundle",
+            cheader_filename = "gjsify-lightningcss-glue.h")]
+    private extern GLib.Bytes? _glue_bundle (string filename,
+                                             string? browserslist,
+                                             bool minify,
+                                             bool source_map,
+                                             bool error_recovery,
+                                             out GLib.Bytes? out_map) throws GLib.Error;
+
+    /**
+     * Engine — stateless one-shot CSS transform pipeline.
+     *
+     * Each call constructs a fresh lightningcss StyleSheet on the Rust
+     * side, optionally lowers per browserslist targets, and prints back
+     * to CSS (with optional minify + source map). Designed for the
+     * @gjsify/rolldown-plugin-gjsify cssAsStringPlugin call site —
+     * single-shot transforms, no plugin/composes/css-modules surface.
+     */
+    public class Engine : GLib.Object {
+
+        /**
+         * transform:
+         * @filename: logical filename for diagnostics (may be null)
+         * @code: input CSS bytes (UTF-8)
+         * @browserslist: browserslist query, e.g. "firefox >= 60"; null
+         *                disables targets-driven lowering
+         * @minify: whitespace-strip + property/selector merging
+         * @source_map: also produce a JSON source map
+         * @out_source_map: (out)(transfer full)(nullable): JSON source
+         *                  map, set only when @source_map was true
+         *
+         * Returns: (transfer full): output CSS as GLib.Bytes. Throws
+         * GjsifyLightningcssError.FAILED on any pipeline error.
+         */
+        public GLib.Bytes transform (string? filename,
+                                     GLib.Bytes code,
+                                     string? browserslist,
+                                     bool minify,
+                                     bool source_map,
+                                     out GLib.Bytes? out_source_map) throws GLib.Error {
+            GLib.Bytes? map = null;
+            var bytes = _glue_transform (filename, code, browserslist,
+                                         minify, source_map, out map);
+            out_source_map = map;
+            if (bytes == null)
+                throw new GLib.Error (GLib.Quark.from_string ("gjsify-lightningcss-error-quark"),
+                                      0, "lightningcss: unknown error (NULL result without GError)");
+            return bytes;
+        }
+
+        /**
+         * bundle:
+         * @filename: entry CSS file path
+         * @browserslist: browserslist query (null disables targets lowering)
+         * @minify: minify the output
+         * @source_map: also produce a JSON source map
+         * @error_recovery: keep parsing after recoverable errors
+         *                  (matches lightningcss `errorRecovery: true`)
+         * @out_source_map: (out)(transfer full)(nullable)
+         *
+         * Returns: (transfer full): bundled output CSS as GLib.Bytes.
+         * Resolves @import chains via lightningcss's built-in
+         * filesystem-backed FileProvider.
+         */
+        public GLib.Bytes bundle (string filename,
+                                  string? browserslist,
+                                  bool minify,
+                                  bool source_map,
+                                  bool error_recovery,
+                                  out GLib.Bytes? out_source_map) throws GLib.Error {
+            GLib.Bytes? map = null;
+            var bytes = _glue_bundle (filename, browserslist, minify,
+                                      source_map, error_recovery, out map);
+            out_source_map = map;
+            if (bytes == null)
+                throw new GLib.Error (GLib.Quark.from_string ("gjsify-lightningcss-error-quark"),
+                                      0, "lightningcss: unknown bundle error");
+            return bytes;
+        }
+    }
+}