@gjsify/rolldown-native 0.4.43 → 0.5.0

package/README.md

@@ -0,0 +1,35 @@
+# @gjsify/rolldown-native
+
+A native Rust cdylib + Vala/GObject bridge that wraps the Rust `rolldown` bundler and exposes it to GJS via `gi://`. This is the default bundler engine used by `gjsify build` under GJS — npm's `rolldown` is an N-API addon that cannot load in GJS, so this bridge is how gjsify bundles without a Node runtime. Includes a complete plugin bridge (`bundleWithPlugins`) for load, transform, resolveId, and render-chunk hooks. Ships prebuilt `.so` + `.typelib` for Linux.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+gjsify install @gjsify/rolldown-native
+```
+
+## Usage
+
+```typescript
+import { hasNativeRolldown, bundle, bundleWithPlugins } from '@gjsify/rolldown-native';
+
+if (hasNativeRolldown()) {
+    // Simple bundle
+    const result = bundle({
+        input: [{ import: 'src/index.ts' }],
+        format: 'esm',
+        minify: false,
+    });
+    for (const item of result.output) {
+        if (item.type === 'chunk') console.log(item.fileName, item.code.length, 'bytes');
+    }
+}
+```
+
+Under normal usage `@gjsify/rolldown-native` is consumed automatically by the gjsify CLI (`gjsify build`) — direct use is only needed when embedding the bundler in custom build tooling.
+
+## License
+
+MIT

package/lib/esm/plugins.js

@@ -1 +1 @@
-import"./_virtual/_rolldown/runtime.js";import{loadNativeRolldown as e}from"./index.js";function getGLib(){let e=globalThis.imports?.gi;if(!e||!e.GLib)throw Error(`@gjsify/rolldown-native: GLib not available (not running under GJS?)`);return e.GLib}const enc=e=>getGLib().Bytes.new(new TextEncoder().encode(e)),dec=e=>new TextDecoder().decode(e.get_data()??new Uint8Array),t=[`load`,`transform`,`resolveId`,`renderChunk`,`banner`,`footer`,`intro`,`outro`,`buildStart`,`buildEnd`,`generateBundle`,`writeBundle`,`closeBundle`];function pluginMeta(e){let n=t.filter(t=>typeof e[t]==`function`),r={name:e.name,hooks:n};return e.idFilter&&(r.idFilter=e.idFilter),r}function bundleWithPlugins(t,n){let r=e();if(!r)return Promise.reject(Error(`@gjsify/rolldown-native: prebuild not available`));let i=new r.BundlerSession,a=new Map;i.connect(`context_response`,(e,t,n)=>{let r=a.get(t);if(!r)return;a.delete(t);let i;try{i=JSON.parse(dec(n))}catch(e){r.reject(e instanceof Error?e:Error(String(e)));return}i.error?r.reject(Error(i.error)):i.id?r.resolve({id:i.id,external:i.external??!1}):r.resolve(null)});function makeContext(e){return{resolve(t,n,r){return new Promise((o,s)=>{let c=i.context_resolve(e,enc(JSON.stringify({specifier:t,importer:n,skipSelf:r?.skipSelf??!0,isEntry:r?.isEntry??!1})));if(c===0){s(Error(`@gjsify/rolldown-native: ctx.resolve('${t}') failed — parent req_id ${e} unknown`));return}a.set(c,{resolve:o,reject:s})})},warn(e){i.context_warn(enc(e))},error(e){throw Error(e)}}}i.connect(`hook_requested`,(e,t,n,r,i)=>{dispatchHook(t,n,r,i)});async function dispatchHook(e,t,r,a){let o;try{o=JSON.parse(dec(a))}catch(e){respondError(t,e);return}let s=n[r];if(!s){respondError(t,Error(`@gjsify/rolldown-native: unknown plugin index ${r}`));return}let c=makeContext(t);try{if(e===`transform`&&s.transform){let e=o,n=i.take_request_payload(t);if(n===null)throw Error(`@gjsify/rolldown-native: transform request for ${e.id} missing payload bytes`);let r=dec(n);respondTransform(t,await s.transform.call(c,r,e.id,e.moduleType));return}respondOk(t,await runHook(s,e,o,c))}catch(e){respondError(t,e)}}function respondOk(e,t){let n=t==null?{kind:`skip`}:{kind:`ok`,value:t};i.respond(e,enc(JSON.stringify(n)))}function respondTransform(e,t){if(t==null){i.respond(e,enc(JSON.stringify({kind:`skip`})));return}let n,r;if(typeof t==`string`)n=t;else if(typeof t==`object`){let e=t;n=e.code,r=e.moduleType}if(typeof n!=`string`){i.respond(e,enc(JSON.stringify({kind:`skip`})));return}let a=getGLib().Bytes.new(new TextEncoder().encode(n));if(!i.set_response_payload(e,a)){respondError(e,Error(`@gjsify/rolldown-native: failed to stash transform response payload for reqId ${e}`));return}i.respond(e,enc(JSON.stringify({kind:`ok`,value:r===void 0?{hasCodeBytes:!0}:{hasCodeBytes:!0,moduleType:r}})))}function respondError(e,t){let n=t instanceof Error?t:Error(String(t));i.respond(e,enc(JSON.stringify({kind:`error`,message:n.message,stack:n.stack})))}return new Promise((e,r)=>{i.connect(`completed`,(t,n)=>{try{e(JSON.parse(dec(n)))}catch(e){r(e instanceof Error?e:Error(String(e)))}}),i.connect(`error_occurred`,(e,t)=>{r(Error(t))});try{i.start(enc(JSON.stringify({options:t,plugins:n.map(pluginMeta)})))}catch(e){r(e instanceof Error?e:Error(String(e)))}})}async function runHook(e,t,n,r){switch(t){case`load`:return e.load?normalizeLoadResult(await e.load.call(r,n.id)):null;case`transform`:return null;case`resolveId`:{if(!e.resolveId)return null;let t=n;return normalizeResolveIdResult(await e.resolveId.call(r,t.specifier,t.importer,{isEntry:t.isEntry}))}case`renderChunk`:{if(!e.renderChunk)return null;let t=n;return normalizeRenderChunkResult(await e.renderChunk.call(r,t.code,{fileName:t.fileName,name:t.name,isEntry:t.isEntry}))}case`banner`:case`footer`:case`intro`:case`outro`:{let i=e[t];if(!i)return null;let a=n;return normalizeAddonResult(await i.call(r,{fileName:a.fileName,name:a.name,isEntry:a.isEntry}))}case`buildStart`:case`buildEnd`:case`generateBundle`:case`writeBundle`:case`closeBundle`:{let n=e[t];return n&&await n.call(r),null}default:throw Error(`@gjsify/rolldown-native: unknown hook '${t}'`)}}function normalizeLoadResult(e){return e==null?null:typeof e==`string`?{code:e}:{code:e.code,moduleType:e.moduleType}}function normalizeResolveIdResult(e){return e==null?null:typeof e==`string`?{id:e}:{id:e.id,external:e.external}}function normalizeRenderChunkResult(e){return e==null?null:typeof e==`string`?{code:e}:{code:e.code}}function normalizeAddonResult(e){return e==null?null:typeof e==`string`?e:e.text}export{bundleWithPlugins};
+import"./_virtual/_rolldown/runtime.js";import{loadNativeRolldown as e}from"./index.js";function getGLib(){let e=globalThis.imports?.gi;if(!e||!e.GLib)throw Error(`@gjsify/rolldown-native: GLib not available (not running under GJS?)`);return e.GLib}const enc=e=>getGLib().Bytes.new(new TextEncoder().encode(e)),dec=e=>new TextDecoder().decode(e.get_data()??new Uint8Array),t=[`load`,`transform`,`resolveId`,`renderChunk`,`banner`,`footer`,`intro`,`outro`,`buildStart`,`buildEnd`,`generateBundle`,`writeBundle`,`closeBundle`];function pluginMeta(e){let n=t.filter(t=>typeof e[t]==`function`),r={name:e.name,hooks:n};return e.idFilter&&(r.idFilter=e.idFilter),r}const n=new Set;function bundleWithPlugins(t,r){let i=e();if(!i)return Promise.reject(Error(`@gjsify/rolldown-native: prebuild not available`));let a=new i.BundlerSession;n.add(a);let o=new Map;a.connect(`context_response`,(e,t,n)=>{let r=o.get(t);if(!r)return;o.delete(t);let i;try{i=JSON.parse(dec(n))}catch(e){r.reject(e instanceof Error?e:Error(String(e)));return}i.error?r.reject(Error(i.error)):i.id?r.resolve({id:i.id,external:i.external??!1}):r.resolve(null)});function makeContext(e){return{resolve(t,n,r){return new Promise((i,s)=>{let c=a.context_resolve(e,enc(JSON.stringify({specifier:t,importer:n,skipSelf:r?.skipSelf??!0,isEntry:r?.isEntry??!1})));if(c===0){s(Error(`@gjsify/rolldown-native: ctx.resolve('${t}') failed — parent req_id ${e} unknown`));return}o.set(c,{resolve:i,reject:s})})},warn(e){a.context_warn(enc(e))},error(e){throw Error(e)}}}a.connect(`hook_requested`,(e,t,n,r,i)=>{dispatchHook(t,n,r,i)});async function dispatchHook(e,t,n,i){let o;try{o=JSON.parse(dec(i))}catch(e){respondError(t,e);return}let s=r[n];if(!s){respondError(t,Error(`@gjsify/rolldown-native: unknown plugin index ${n}`));return}let c=makeContext(t);try{if(e===`transform`&&s.transform){let e=o,n=a.take_request_payload(t);if(n===null)throw Error(`@gjsify/rolldown-native: transform request for ${e.id} missing payload bytes`);let r=dec(n);respondTransform(t,await s.transform.call(c,r,e.id,e.moduleType));return}respondOk(t,await runHook(s,e,o,c))}catch(e){respondError(t,e)}}function respondOk(e,t){let n=t==null?{kind:`skip`}:{kind:`ok`,value:t};a.respond(e,enc(JSON.stringify(n)))}function respondTransform(e,t){if(t==null){a.respond(e,enc(JSON.stringify({kind:`skip`})));return}let n,r;if(typeof t==`string`)n=t;else if(typeof t==`object`){let e=t;n=e.code,r=e.moduleType}if(typeof n!=`string`){a.respond(e,enc(JSON.stringify({kind:`skip`})));return}let i=getGLib().Bytes.new(new TextEncoder().encode(n));if(!a.set_response_payload(e,i)){respondError(e,Error(`@gjsify/rolldown-native: failed to stash transform response payload for reqId ${e}`));return}a.respond(e,enc(JSON.stringify({kind:`ok`,value:r===void 0?{hasCodeBytes:!0}:{hasCodeBytes:!0,moduleType:r}})))}function respondError(e,t){let n=t instanceof Error?t:Error(String(t));a.respond(e,enc(JSON.stringify({kind:`error`,message:n.message,stack:n.stack})))}let closeSession=()=>{n.delete(a);let e=a;try{e.close?.()}catch{}};return new Promise((e,n)=>{a.connect(`completed`,(t,r)=>{try{e(JSON.parse(dec(r)))}catch(e){n(e instanceof Error?e:Error(String(e)))}}),a.connect(`error_occurred`,(e,t)=>{n(Error(t))});try{a.start(enc(JSON.stringify({options:t,plugins:r.map(pluginMeta)})))}catch(e){n(e instanceof Error?e:Error(String(e)))}}).finally(closeSession)}async function runHook(e,t,n,r){switch(t){case`load`:return e.load?normalizeLoadResult(await e.load.call(r,n.id)):null;case`transform`:return null;case`resolveId`:{if(!e.resolveId)return null;let t=n;return normalizeResolveIdResult(await e.resolveId.call(r,t.specifier,t.importer,{isEntry:t.isEntry}))}case`renderChunk`:{if(!e.renderChunk)return null;let t=n;return normalizeRenderChunkResult(await e.renderChunk.call(r,t.code,{fileName:t.fileName,name:t.name,isEntry:t.isEntry}))}case`banner`:case`footer`:case`intro`:case`outro`:{let i=e[t];if(!i)return null;let a=n;return normalizeAddonResult(await i.call(r,{fileName:a.fileName,name:a.name,isEntry:a.isEntry}))}case`buildStart`:case`buildEnd`:case`generateBundle`:case`writeBundle`:case`closeBundle`:{let n=e[t];return n&&await n.call(r),null}default:throw Error(`@gjsify/rolldown-native: unknown hook '${t}'`)}}function normalizeLoadResult(e){return e==null?null:typeof e==`string`?{code:e}:{code:e.code,moduleType:e.moduleType}}function normalizeResolveIdResult(e){return e==null?null:typeof e==`string`?{id:e}:{id:e.id,external:e.external}}function normalizeRenderChunkResult(e){return e==null?null:typeof e==`string`?{code:e}:{code:e.code}}function normalizeAddonResult(e){return e==null?null:typeof e==`string`?e:e.text}export{bundleWithPlugins};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/rolldown-native",
-    "version": "0.4.43",
+    "version": "0.5.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",
@@ -47,8 +47,8 @@
         "@girs/gobject-2.0": "2.88.0-4.0.4"
     },
     "devDependencies": {
-        "@gjsify/cli": "^0.4.43",
-        "@types/node": "^25.9.1",
+        "@gjsify/cli": "^0.5.0",
+        "@types/node": "^25.9.2",
         "typescript": "^6.0.3"
     },
     "author": "Pascal Garber <pascal@artandcode.studio>",

package/prebuilds/linux-aarch64/GjsifyRolldown-1.0.gir

@@ -61,6 +61,16 @@
 				</parameter>
 			</parameters>
 		</method>
+		<method name="close" c:identifier="gjsify_rolldown_bundler_session_close">
+			<return-value transfer-ownership="full">
+				<type name="none" c:type="void"/>
+			</return-value>
+			<parameters>
+				<instance-parameter name="self" transfer-ownership="none">
+					<type name="GjsifyRolldown.BundlerSession" c:type="GjsifyRolldownBundlerSession*"/>
+				</instance-parameter>
+			</parameters>
+		</method>
 		<method name="respond" c:identifier="gjsify_rolldown_bundler_session_respond">
 			<return-value transfer-ownership="full">
 				<type name="none" c:type="void"/>

package/prebuilds/linux-x86_64/GjsifyRolldown-1.0.gir

@@ -61,6 +61,16 @@
 				</parameter>
 			</parameters>
 		</method>
+		<method name="close" c:identifier="gjsify_rolldown_bundler_session_close">
+			<return-value transfer-ownership="full">
+				<type name="none" c:type="void"/>
+			</return-value>
+			<parameters>
+				<instance-parameter name="self" transfer-ownership="none">
+					<type name="GjsifyRolldown.BundlerSession" c:type="GjsifyRolldownBundlerSession*"/>
+				</instance-parameter>
+			</parameters>
+		</method>
 		<method name="respond" c:identifier="gjsify_rolldown_bundler_session_respond">
 			<return-value transfer-ownership="full">
 				<type name="none" c:type="void"/>

package/src/rust/src/plugin_proxy.rs

@@ -368,8 +368,10 @@ pub struct JsPluginProxy {
     /// the same session via Arc clone in the session constructor.
     pub next_request_id: std::sync::Arc<AtomicU64>,
     /// Wakeup pipe written after each request.send() so the Vala
-    /// source on the main loop can react.
-    pub request_eventfd: i32,
+    /// source on the main loop can react. Owned handle (see
+    /// `SessionShared`): keeps the fd number reserved even when this
+    /// proxy outlives the session's runtime shutdown.
+    pub request_eventfd: std::sync::Arc<std::os::fd::OwnedFd>,
     /// Maximum time we wait for a JS response before failing the
     /// build with a timeout error. Defaults to 60s.
     pub response_timeout: Duration,
@@ -467,14 +469,7 @@ impl JsPluginProxy {
             return Err(anyhow!("rolldown: plugin channel closed (session aborted)"));
         }
 
-        let one: u64 = 1;
-        unsafe {
-            libc::write(
-                self.request_eventfd,
-                &one as *const u64 as *const libc::c_void,
-                8,
-            );
-        }
+        crate::session::wake_eventfd(&self.request_eventfd);
 
         let result = tokio::time::timeout(self.response_timeout, reply_rx).await;
         // Clear the context registration regardless of outcome; the

package/src/rust/src/session.rs

@@ -17,6 +17,7 @@
 //!      eventfd, see Phase B.2 — for B.1 we expose `wait()` only).
 
 use std::ffi::CString;
+use std::os::fd::{AsRawFd, FromRawFd, OwnedFd};
 use std::os::raw::{c_char, c_int};
 use std::ptr;
 use std::sync::Arc;
@@ -69,7 +70,10 @@ pub struct SessionShared {
     pub contexts: Mutex<std::collections::HashMap<u64, PluginContext>>,
     pub next_child_id: AtomicU64,
     pub context_response_tx: Sender<ContextResolveResponse>,
-    pub context_response_eventfd: c_int,
+    /// Owned handle — the fd stays reserved for as long as any clone
+    /// (incl. leaked post-shutdown tasks) is alive, so a stale write
+    /// can never land in a recycled fd number of a later session.
+    pub context_response_eventfd: Arc<OwnedFd>,
     pub context_warnings: Mutex<Vec<String>>,
     /// Phase B.4 — parallel bytes-payload slots keyed by req_id.
     /// `request_payloads` holds Rust → JS payloads (e.g. transform
@@ -93,11 +97,11 @@ pub struct BundleSession {
     /// Pending requests waiting on JS reply. Keyed by req_id.
     pub pending: Mutex<std::collections::HashMap<u64, oneshot::Sender<HookResponse>>>,
     /// eventfd for "request available" wakeup → GLib main loop watches.
-    pub request_eventfd: c_int,
+    pub request_eventfd: Arc<OwnedFd>,
     /// Result of the bundle task once complete. None while still running.
     pub result: Mutex<Option<Result<String, String>>>,
     /// Completion eventfd: written exactly once when `result` is set.
-    pub complete_eventfd: c_int,
+    pub complete_eventfd: Arc<OwnedFd>,
     /// Cancel flag — set by the C side via `cancel()`. tokio task
     /// observes via shared atomic and aborts.
     pub cancelled: Arc<std::sync::atomic::AtomicBool>,
@@ -167,26 +171,34 @@ pub extern "C" fn gjsify_rolldown_session_start(
     // Create the eventfd pair. EFD_NONBLOCK so writes never block;
     // EFD_SEMAPHORE off (we use counter-mode so JS can read once
     // per drain cycle and process all pending requests in a loop).
+    // Each fd is wrapped in Arc<OwnedFd> immediately: every holder
+    // (proxies, the bundle task, SessionShared, the session itself)
+    // keeps a clone, so the fd number stays reserved until the LAST
+    // user — including tasks leaked past the runtime shutdown
+    // timeout — has dropped it. Closing eagerly in session_free while
+    // such tasks still hold the raw number let their deferred
+    // `libc::write` land in whatever fd the kernel recycled the
+    // number into (issue #501's stale-fd hazard).
     let request_eventfd = unsafe { libc::eventfd(0, libc::EFD_NONBLOCK | libc::EFD_CLOEXEC) };
     if request_eventfd < 0 {
         unsafe { *err_out = err_to_cstr("rolldown: eventfd(request) failed".to_string()) };
         return ptr::null_mut();
     }
+    let request_eventfd = Arc::new(unsafe { OwnedFd::from_raw_fd(request_eventfd) });
     let complete_eventfd = unsafe { libc::eventfd(0, libc::EFD_NONBLOCK | libc::EFD_CLOEXEC) };
     if complete_eventfd < 0 {
-        unsafe { libc::close(request_eventfd) };
         unsafe { *err_out = err_to_cstr("rolldown: eventfd(complete) failed".to_string()) };
         return ptr::null_mut();
     }
+    let complete_eventfd = Arc::new(unsafe { OwnedFd::from_raw_fd(complete_eventfd) });
 
     let context_response_eventfd =
         unsafe { libc::eventfd(0, libc::EFD_NONBLOCK | libc::EFD_CLOEXEC) };
     if context_response_eventfd < 0 {
-        unsafe { libc::close(request_eventfd) };
-        unsafe { libc::close(complete_eventfd) };
         unsafe { *err_out = err_to_cstr("rolldown: eventfd(context_response) failed".to_string()) };
         return ptr::null_mut();
     }
+    let context_response_eventfd = Arc::new(unsafe { OwnedFd::from_raw_fd(context_response_eventfd) });
 
     let cancelled = Arc::new(std::sync::atomic::AtomicBool::new(false));
     let (request_tx, request_rx) = unbounded::<HookRequest>();
@@ -197,7 +209,7 @@ pub extern "C" fn gjsify_rolldown_session_start(
         contexts: Mutex::new(std::collections::HashMap::new()),
         next_child_id: AtomicU64::new(1),
         context_response_tx,
-        context_response_eventfd,
+        context_response_eventfd: context_response_eventfd.clone(),
         context_warnings: Mutex::new(Vec::new()),
         request_payloads: Mutex::new(std::collections::HashMap::new()),
         response_payloads: Mutex::new(std::collections::HashMap::new()),
@@ -222,7 +234,7 @@ pub extern "C" fn gjsify_rolldown_session_start(
                 hooks: meta.hooks.clone(),
                 request_tx: request_tx.clone(),
                 next_request_id: next_request_id.clone(),
-                request_eventfd,
+                request_eventfd: request_eventfd.clone(),
                 response_timeout: Duration::from_secs(60),
                 load_id_filter,
                 transform_id_filter,
@@ -234,9 +246,6 @@ pub extern "C" fn gjsify_rolldown_session_start(
     {
         Ok(v) => v,
         Err(msg) => {
-            unsafe { libc::close(request_eventfd) };
-            unsafe { libc::close(complete_eventfd) };
-            unsafe { libc::close(context_response_eventfd) };
             unsafe { *err_out = err_to_cstr(msg) };
             return ptr::null_mut();
         }
@@ -254,9 +263,6 @@ pub extern "C" fn gjsify_rolldown_session_start(
     {
         Ok(r) => r,
         Err(e) => {
-            unsafe { libc::close(request_eventfd) };
-            unsafe { libc::close(complete_eventfd) };
-            unsafe { libc::close(context_response_eventfd) };
             unsafe { *err_out = err_to_cstr(format!("rolldown: tokio init: {e}")) };
             return ptr::null_mut();
         }
@@ -264,7 +270,7 @@ pub extern "C" fn gjsify_rolldown_session_start(
 
     let result_slot: Arc<Mutex<Option<Result<String, String>>>> = Arc::new(Mutex::new(None));
     let result_slot_clone = result_slot.clone();
-    let complete_eventfd_for_task = complete_eventfd;
+    let complete_eventfd_for_task = complete_eventfd.clone();
     let cancelled_for_task = cancelled.clone();
     let shared_for_task = shared.clone();
 
@@ -276,14 +282,7 @@ pub extern "C" fn gjsify_rolldown_session_start(
         };
         *result_slot_clone.lock().unwrap() = Some(final_json);
         // Signal completion to the GLib main loop.
-        let one: u64 = 1;
-        unsafe {
-            libc::write(
-                complete_eventfd_for_task,
-                &one as *const u64 as *const libc::c_void,
-                8,
-            );
-        }
+        wake_eventfd(&complete_eventfd_for_task);
     });
 
     let session = Box::new(BundleSession {
@@ -390,7 +389,7 @@ pub extern "C" fn gjsify_rolldown_session_request_fd(session: *mut BundleSession
     if session.is_null() {
         return -1;
     }
-    unsafe { (*session).request_eventfd }
+    unsafe { (*session).request_eventfd.as_raw_fd() }
 }
 
 #[unsafe(no_mangle)]
@@ -398,7 +397,7 @@ pub extern "C" fn gjsify_rolldown_session_complete_fd(session: *mut BundleSessio
     if session.is_null() {
         return -1;
     }
-    unsafe { (*session).complete_eventfd }
+    unsafe { (*session).complete_eventfd.as_raw_fd() }
 }
 
 /// Drain one pending request. Returns NULL when the channel is
@@ -541,14 +540,12 @@ pub extern "C" fn gjsify_rolldown_session_free(session: *mut BundleSession) {
     }
     unregister_result_slot(session);
     let boxed = unsafe { Box::from_raw(session) };
-    unsafe {
-        libc::close(boxed.request_eventfd);
-        libc::close(boxed.complete_eventfd);
-        libc::close(boxed.shared.context_response_eventfd);
-    }
-    // Dropping the runtime aborts all in-flight tasks. shutdown_timeout
-    // gives them up to 500ms to drain; any remaining workers are
-    // terminated. Prevents the GJS process exit from hanging.
+    // Shut the runtime down FIRST (up to 500ms drain; workers that
+    // don't finish in time are leaked), THEN let the eventfds drop.
+    // The fds are Arc<OwnedFd>, so even a task leaked past the
+    // shutdown timeout keeps its clone alive — the fd number stays
+    // reserved and a deferred stale write can never corrupt whatever
+    // fd the kernel would otherwise have recycled the number into.
     boxed.runtime.shutdown_timeout(Duration::from_millis(500));
 }
 
@@ -612,7 +609,7 @@ pub extern "C" fn gjsify_rolldown_session_context_resolve(
                 error: Some(format!("rolldown: malformed context_resolve args JSON: {e}")),
             };
             let _ = session.shared.context_response_tx.send(resp);
-            wake_eventfd(session.shared.context_response_eventfd);
+            wake_eventfd(&session.shared.context_response_eventfd);
             return child_id;
         }
     };
@@ -657,7 +654,7 @@ pub extern "C" fn gjsify_rolldown_session_context_resolve(
             },
         };
         let _ = shared.context_response_tx.send(resp);
-        wake_eventfd(shared.context_response_eventfd);
+        wake_eventfd(&shared.context_response_eventfd);
     });
 
     child_id
@@ -693,7 +690,7 @@ pub extern "C" fn gjsify_rolldown_session_context_response_fd(
         return -1;
     }
     let session = unsafe { &*session };
-    session.shared.context_response_eventfd
+    session.shared.context_response_eventfd.as_raw_fd()
 }
 
 /// FFI: drain one pending context-resolve response. Returns NULL when
@@ -723,10 +720,10 @@ pub extern "C" fn gjsify_rolldown_session_next_context_response(
     CString::new(json).ok().map(|c| c.into_raw()).unwrap_or(ptr::null_mut())
 }
 
-fn wake_eventfd(fd: c_int) {
+pub(crate) fn wake_eventfd(fd: &OwnedFd) {
     let one: u64 = 1;
     unsafe {
-        libc::write(fd, &one as *const u64 as *const libc::c_void, 8);
+        libc::write(fd.as_raw_fd(), &one as *const u64 as *const libc::c_void, 8);
     }
 }
 

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

@@ -175,9 +175,18 @@ gjsify_rolldown_glue_session_take_request_payload (BundleSession *session,
   if (session == NULL) return NULL;
   size_t len = 0;
   uint8_t *buf = gjsify_rolldown_session_take_request_payload (session, req_id, &len);
-  if (buf == NULL || len == 0) return NULL;
+  /* NULL buf = no payload was stashed for this req_id (genuine miss) → NULL.
+   * A non-NULL buf with len == 0 is an EMPTY-but-present payload (e.g. the
+   * `transform` hook on rolldown's virtual `\0rolldown/empty.js` module, whose
+   * code is ""). It MUST yield an empty GBytes, NOT NULL — otherwise the JS
+   * adapter reads `take_request_payload() === null` and throws "missing payload
+   * bytes", which is exactly what broke the CLI self-build. Don't fold len==0
+   * into the miss case. */
+  if (buf == NULL) return NULL;
   /* Copy into GLib heap and free the Rust allocation immediately so
-   * GBytes refcount/lifetime stays inside the GLib side. */
+   * GBytes refcount/lifetime stays inside the GLib side. g_bytes_new copies
+   * `len` bytes; for len == 0 it never dereferences `buf`, so the Rust
+   * dangling-but-aligned zero-length pointer is safe here. */
   GBytes *out = g_bytes_new (buf, len);
   gjsify_rolldown_session_free_payload (buf, len);
   return out;

package/src/vala/rolldown.vala

@@ -213,17 +213,33 @@ namespace GjsifyRolldown {
             // Watch the eventfds on the GLib main loop. add_full hands
             // the source priority + condition; we own the fd lifetime
             // via Rust, so don't pass close_fd:true.
+            //
+            // IMPORTANT: each watch source holds a strong GObject ref on
+            // the session (the explicit `this.ref ()` below, released 1:1
+            // in teardown_sources()/close() when the source is removed).
+            // `add_watch (cond, on_request_ready)` alone passes `this` as
+            // raw user_data WITHOUT a ref, so a session whose JS wrapper
+            // became unreachable mid-build (it is only kept alive through
+            // its own signal-handler closures — a self cycle) gets
+            // collected by the SpiderMonkey GC: dispose() removes the
+            // watch sources while the Rust build is still running, every
+            // later eventfd wake lands on an unwatched fd, and the build
+            // stalls forever (issue #501). The extra refs also flip GJS's
+            // toggle-ref into "keep the JS wrapper rooted" mode, so the
+            // signal closures survive until the sources are dropped.
             var req_chan = new GLib.IOChannel.unix_new (req_fd);
             req_chan.set_close_on_unref (false);
             req_chan.set_encoding (null);
             req_chan.set_buffered (false);
             _request_source_id = req_chan.add_watch (GLib.IOCondition.IN, on_request_ready);
+            this.ref ();
 
             var comp_chan = new GLib.IOChannel.unix_new (comp_fd);
             comp_chan.set_close_on_unref (false);
             comp_chan.set_encoding (null);
             comp_chan.set_buffered (false);
             _complete_source_id = comp_chan.add_watch (GLib.IOCondition.IN, on_complete_ready);
+            this.ref ();
 
             int ctx_fd = _session_context_response_fd (_handle);
             var ctx_chan = new GLib.IOChannel.unix_new (ctx_fd);
@@ -231,6 +247,25 @@ namespace GjsifyRolldown {
             ctx_chan.set_encoding (null);
             ctx_chan.set_buffered (false);
             _ctx_response_source_id = ctx_chan.add_watch (GLib.IOCondition.IN, on_ctx_response_ready);
+            this.ref ();
+        }
+
+        /**
+         * close — release the session's resources.
+         *
+         * Removes the three GLib eventfd watch sources and drops the owned
+         * Rust handle (whose `free_function`, gjsify_rolldown_session_free,
+         * tears down the bundler + tokio runtime + eventfds). Without this,
+         * every bundle leaked its session for the process lifetime — the
+         * watch sources hold a ref on the session, so neither the GObject
+         * nor the Rust side could ever be collected. Idempotent; safe to
+         * call before start() (no-op) and from a JS signal-handler
+         * continuation (the watches are removed by id, not from within
+         * their own dispatch).
+         */
+        public void close () {
+            teardown_sources ();
+            _handle = null;
         }
 
         private bool on_ctx_response_ready (GLib.IOChannel source, GLib.IOCondition cond) {
@@ -363,17 +398,24 @@ namespace GjsifyRolldown {
         }
 
         private void teardown_sources () {
+            // Each removal releases the strong ref taken in start()
+            // when the source was added — strictly 1:1 (the id is
+            // zeroed before unref, so a re-entrant call can never
+            // double-release).
             if (_request_source_id != 0) {
                 GLib.Source.remove (_request_source_id);
                 _request_source_id = 0;
+                this.unref ();
             }
             if (_complete_source_id != 0) {
                 GLib.Source.remove (_complete_source_id);
                 _complete_source_id = 0;
+                this.unref ();
             }
             if (_ctx_response_source_id != 0) {
                 GLib.Source.remove (_ctx_response_source_id);
                 _ctx_response_source_id = 0;
+                this.unref ();
             }
         }