@gjsify/rolldown-native 0.4.0 → 0.4.3

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

@@ -0,0 +1,195 @@
+/*
+ * GLib-friendly glue for gjsify_rolldown. See gjsify-rolldown-glue.h.
+ */
+
+#include "gjsify-rolldown-glue.h"
+#include <stdbool.h>
+#include <string.h>
+
+GQuark
+gjsify_rolldown_error_quark (void)
+{
+  return g_quark_from_static_string ("gjsify-rolldown-error-quark");
+}
+
+GBytes *
+gjsify_rolldown_glue_bundle (GBytes  *options_json,
+                             GError **error)
+{
+  if (options_json == NULL)
+    {
+      g_set_error_literal (error,
+                           GJSIFY_ROLLDOWN_ERROR,
+                           GJSIFY_ROLLDOWN_ERROR_FAILED,
+                           "rolldown: NULL options JSON");
+      return NULL;
+    }
+
+  gsize opts_len = 0;
+  const char *opts_data = (const char *) g_bytes_get_data (options_json, &opts_len);
+
+  GjsifyRolldownResult res = gjsify_rolldown_bundle (opts_data, opts_len);
+
+  if (res.error != NULL)
+    {
+      g_set_error_literal (error,
+                           GJSIFY_ROLLDOWN_ERROR,
+                           GJSIFY_ROLLDOWN_ERROR_FAILED,
+                           res.error);
+      gjsify_rolldown_result_free (res);
+      return NULL;
+    }
+
+  /* Copy out into GLib heap so the Rust result can be freed immediately. */
+  GBytes *out = (res.output != NULL && res.output_len > 0)
+                  ? g_bytes_new (res.output, res.output_len)
+                  : g_bytes_new_static ("", 0);
+
+  gjsify_rolldown_result_free (res);
+  return out;
+}
+
+/* ----------------------------------------------------------------- */
+/* Phase B.1+: plugin-callback bridge glue.                          */
+/* ----------------------------------------------------------------- */
+
+BundleSession *
+gjsify_rolldown_glue_session_start (GBytes  *args_json,
+                                    GError **error)
+{
+  if (args_json == NULL)
+    {
+      g_set_error_literal (error,
+                           GJSIFY_ROLLDOWN_ERROR,
+                           GJSIFY_ROLLDOWN_ERROR_FAILED,
+                           "rolldown: NULL args JSON");
+      return NULL;
+    }
+  gsize len = 0;
+  const char *data = (const char *) g_bytes_get_data (args_json, &len);
+  char *err = NULL;
+  BundleSession *session = gjsify_rolldown_session_start (data, len, &err);
+  if (session == NULL)
+    {
+      g_set_error_literal (error,
+                           GJSIFY_ROLLDOWN_ERROR,
+                           GJSIFY_ROLLDOWN_ERROR_FAILED,
+                           err != NULL ? err : "rolldown: unknown session-start error");
+      if (err != NULL) gjsify_rolldown_session_free_error (err);
+      return NULL;
+    }
+  return session;
+}
+
+GBytes *
+gjsify_rolldown_glue_session_next_request (BundleSession *session)
+{
+  if (session == NULL) return NULL;
+  size_t len = 0;
+  char *json = gjsify_rolldown_session_next_request (session, &len);
+  if (json == NULL || len == 0) return NULL;
+  GBytes *out = g_bytes_new (json, len);
+  gjsify_rolldown_session_free_string (json);
+  return out;
+}
+
+gboolean
+gjsify_rolldown_glue_session_respond (BundleSession *session,
+                                      guint64        req_id,
+                                      GBytes        *response_json)
+{
+  if (session == NULL || response_json == NULL) return FALSE;
+  gsize len = 0;
+  const char *data = (const char *) g_bytes_get_data (response_json, &len);
+  return gjsify_rolldown_session_respond (session, req_id, data, len);
+}
+
+GBytes *
+gjsify_rolldown_glue_session_try_result (BundleSession *session,
+                                         GError       **error)
+{
+  if (session == NULL) return NULL;
+  size_t len = 0;
+  bool is_error = false;
+  char *json = gjsify_rolldown_session_try_result (session, &len, &is_error);
+  if (json == NULL) return NULL;          /* still building */
+  if (is_error)
+    {
+      g_set_error_literal (error,
+                           GJSIFY_ROLLDOWN_ERROR,
+                           GJSIFY_ROLLDOWN_ERROR_FAILED,
+                           json);
+      gjsify_rolldown_session_free_string (json);
+      return NULL;
+    }
+  GBytes *out = g_bytes_new (json, len);
+  gjsify_rolldown_session_free_string (json);
+  return out;
+}
+
+/* ----------------------------------------------------------------- */
+/* Phase B.3 — nested-protocol glue.                                 */
+/* ----------------------------------------------------------------- */
+
+guint64
+gjsify_rolldown_glue_session_context_resolve (BundleSession *session,
+                                              guint64        parent_req_id,
+                                              GBytes        *args_json)
+{
+  if (session == NULL || args_json == NULL) return 0;
+  gsize len = 0;
+  const char *data = (const char *) g_bytes_get_data (args_json, &len);
+  return gjsify_rolldown_session_context_resolve (session, parent_req_id, data, len);
+}
+
+void
+gjsify_rolldown_glue_session_context_warn (BundleSession *session,
+                                           GBytes        *message)
+{
+  if (session == NULL || message == NULL) return;
+  gsize len = 0;
+  const char *data = (const char *) g_bytes_get_data (message, &len);
+  gjsify_rolldown_session_context_warn (session, data, len);
+}
+
+GBytes *
+gjsify_rolldown_glue_session_next_context_response (BundleSession *session)
+{
+  if (session == NULL) return NULL;
+  size_t len = 0;
+  char *json = gjsify_rolldown_session_next_context_response (session, &len);
+  if (json == NULL || len == 0) return NULL;
+  GBytes *out = g_bytes_new (json, len);
+  gjsify_rolldown_session_free_string (json);
+  return out;
+}
+
+/* ----------------------------------------------------------------- */
+/* Phase B.4 — bytes-payload side-channel glue.                       */
+/* ----------------------------------------------------------------- */
+
+GBytes *
+gjsify_rolldown_glue_session_take_request_payload (BundleSession *session,
+                                                   guint64        req_id)
+{
+  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;
+  /* Copy into GLib heap and free the Rust allocation immediately so
+   * GBytes refcount/lifetime stays inside the GLib side. */
+  GBytes *out = g_bytes_new (buf, len);
+  gjsify_rolldown_session_free_payload (buf, len);
+  return out;
+}
+
+gboolean
+gjsify_rolldown_glue_session_set_response_payload (BundleSession *session,
+                                                   guint64        req_id,
+                                                   GBytes        *bytes)
+{
+  if (session == NULL || bytes == NULL) return FALSE;
+  gsize len = 0;
+  const uint8_t *data = (const uint8_t *) g_bytes_get_data (bytes, &len);
+  return gjsify_rolldown_session_set_response_payload (session, req_id, data, len);
+}

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

@@ -0,0 +1,100 @@
+/*
+ * GLib-friendly wrapper around the Rust rolldown shim. Same pattern
+ * as @gjsify/lightningcss-native: copy the Rust-allocated buffer into
+ * GBytes (refcount-friendly for SpiderMonkey GC) and free the Rust
+ * result immediately. Errors become GError on the GJSIFY_ROLLDOWN quark.
+ */
+
+#ifndef GJSIFY_ROLLDOWN_GLUE_H
+#define GJSIFY_ROLLDOWN_GLUE_H
+
+#include <glib.h>
+#include "gjsify-rolldown.h"
+
+G_BEGIN_DECLS
+
+#define GJSIFY_ROLLDOWN_ERROR (gjsify_rolldown_error_quark ())
+
+typedef enum {
+  GJSIFY_ROLLDOWN_ERROR_FAILED = 0,
+} GjsifyRolldownError;
+
+GQuark gjsify_rolldown_error_quark (void);
+
+/**
+ * gjsify_rolldown_glue_bundle:
+ * @options_json: (transfer none): UTF-8 JSON document matching
+ *                rolldown's BundlerOptions serde shape (camelCase).
+ * @error: (out)(optional): GError on failure
+ *
+ * Returns: (transfer full): output JSON as GBytes, or NULL on error.
+ */
+GBytes *gjsify_rolldown_glue_bundle (GBytes  *options_json,
+                                     GError **error);
+
+/* ----------------------------------------------------------------- */
+/* Phase B.1+: plugin-callback bridge.                                */
+/* ----------------------------------------------------------------- */
+
+/* Start a session. @args_json shape: `{"options": ..., "plugins": [...]}`.
+ * Returns NULL on error (sets *error). Session must be freed via
+ * gjsify_rolldown_session_free (the Rust extern, not a glue wrapper). */
+BundleSession *gjsify_rolldown_glue_session_start (GBytes  *args_json,
+                                                   GError **error);
+
+/* Drain one pending hook request as GBytes. Returns NULL when the
+ * channel is empty (NOT an error — just means caller should wait
+ * for the next request_fd wake). */
+GBytes *gjsify_rolldown_glue_session_next_request (BundleSession *session);
+
+/* Forward the JS-side response. */
+gboolean gjsify_rolldown_glue_session_respond (BundleSession *session,
+                                               guint64        req_id,
+                                               GBytes        *response_json);
+
+/* Read the bundle result. Returns NULL while still in flight. On
+ * completion: GBytes with BundleOutputJson on success, or NULL +
+ * GError set on build failure. */
+GBytes *gjsify_rolldown_glue_session_try_result (BundleSession *session,
+                                                 GError       **error);
+
+/* ----------------------------------------------------------------- */
+/* Phase B.3 — nested-protocol glue.                                  */
+/* ----------------------------------------------------------------- */
+
+/* Trigger ctx.resolve() for the JS plugin currently handling
+ * @parent_req_id. Returns the child request ID immediately; the
+ * sub-result lands on the context-response queue. Returns 0 on
+ * error (parent unknown / args malformed). */
+guint64 gjsify_rolldown_glue_session_context_resolve (BundleSession *session,
+                                                      guint64        parent_req_id,
+                                                      GBytes        *args_json);
+
+/* Append a string to the build's warnings list. */
+void    gjsify_rolldown_glue_session_context_warn (BundleSession *session,
+                                                   GBytes        *message);
+
+/* Drain one queued context-resolve sub-result. Returns NULL when
+ * the queue is empty. */
+GBytes *gjsify_rolldown_glue_session_next_context_response (BundleSession *session);
+
+/* ----------------------------------------------------------------- */
+/* Phase B.4 — bytes-payload side-channel.                            */
+/* ----------------------------------------------------------------- */
+
+/* Take the request-payload bytes Rust stashed for @req_id. Returns
+ * NULL when empty. The returned GBytes is independent of Rust's
+ * allocation (data was copied into a GLib heap buffer + the Rust
+ * payload freed in-place). */
+GBytes *gjsify_rolldown_glue_session_take_request_payload (BundleSession *session,
+                                                           guint64        req_id);
+
+/* Stash bytes Rust should read after the JS handler responds — the
+ * transform hook's output code. */
+gboolean gjsify_rolldown_glue_session_set_response_payload (BundleSession *session,
+                                                            guint64        req_id,
+                                                            GBytes        *bytes);
+
+G_END_DECLS
+
+#endif /* GJSIFY_ROLLDOWN_GLUE_H */

package/src/vala/gjsify-rolldown.h

@@ -0,0 +1,136 @@
+/*
+ * Hand-written C header matching the Rust extern "C" surface of
+ * the gjsify_rolldown cdylib (src/rust/src/lib.rs).
+ */
+
+#ifndef GJSIFY_ROLLDOWN_H
+#define GJSIFY_ROLLDOWN_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  char    *output;       /* NUL-terminated UTF-8 JSON, NULL on error */
+  size_t   output_len;
+  char    *error;        /* NUL-terminated UTF-8 message, NULL on success */
+} GjsifyRolldownResult;
+
+GjsifyRolldownResult gjsify_rolldown_bundle (const char *options_json,
+                                             size_t      options_json_len);
+
+void gjsify_rolldown_result_free (GjsifyRolldownResult result);
+
+/* ----------------------------------------------------------------- */
+/* Phase B.1+: plugin-callback bridge.                                */
+/* ----------------------------------------------------------------- */
+
+typedef struct _BundleSession BundleSession;
+
+/* Start a new bundle session. JSON payload shape is
+ * `{"options": <BundlerOptions>, "plugins": [{"name": "...", "hooks": [...]}]}`.
+ *
+ * Returns NULL on error and sets *err_out to a heap-allocated
+ * NUL-terminated message (caller frees via
+ * gjsify_rolldown_session_free_error). Otherwise returns an opaque
+ * BundleSession handle owned by the caller — must be freed via
+ * gjsify_rolldown_session_free when done. */
+BundleSession *gjsify_rolldown_session_start (const char  *args_json,
+                                              size_t       args_json_len,
+                                              char       **err_out);
+
+/* Eventfd that the GLib main loop should watch with G_IO_IN. Wakes
+ * whenever a hook request is queued. Caller MUST NOT close it. */
+int  gjsify_rolldown_session_request_fd  (BundleSession *session);
+
+/* Eventfd that wakes when the bundle task is fully done. */
+int  gjsify_rolldown_session_complete_fd (BundleSession *session);
+
+/* Drain one request as JSON. Returns NULL when the channel is empty
+ * (out_len set to 0). Caller frees via
+ * gjsify_rolldown_session_free_string. */
+char *gjsify_rolldown_session_next_request (BundleSession *session,
+                                            size_t        *out_len);
+
+/* Submit the JS-side response for a previously-pulled request. */
+bool  gjsify_rolldown_session_respond      (BundleSession *session,
+                                            uint64_t       req_id,
+                                            const char    *response_json,
+                                            size_t         response_json_len);
+
+/* Returns NULL while the build is still running. On completion: a
+ * JSON document (BundleOutputJson on success or {"error": "..."} on
+ * failure; *is_error tells which). Caller frees via
+ * gjsify_rolldown_session_free_string. */
+char *gjsify_rolldown_session_try_result   (BundleSession *session,
+                                            size_t        *out_len,
+                                            bool          *is_error);
+
+void  gjsify_rolldown_session_cancel       (BundleSession *session);
+void  gjsify_rolldown_session_free         (BundleSession *session);
+void  gjsify_rolldown_session_free_string  (char *s);
+void  gjsify_rolldown_session_free_error   (char *s);
+
+/* ----------------------------------------------------------------- */
+/* Phase B.3 — nested protocol for plugin-context callbacks.         */
+/* ----------------------------------------------------------------- */
+
+/* Trigger a `ctx.resolve()` callback on behalf of the JS plugin
+ * handler currently running for `parent_req_id`. Returns a child
+ * request ID immediately; the actual sub-result lands on the
+ * context-response channel (drained via
+ * gjsify_rolldown_session_next_context_response). Returns 0 on
+ * error (parent_req_id unknown / args malformed). */
+uint64_t gjsify_rolldown_session_context_resolve (BundleSession *session,
+                                                  uint64_t       parent_req_id,
+                                                  const char    *args_json,
+                                                  size_t         args_json_len);
+
+/* Append a string to the build's warnings list. Surfaces in
+ * BundleOutputJson.warnings. */
+void  gjsify_rolldown_session_context_warn (BundleSession *session,
+                                            const char    *message,
+                                            size_t         message_len);
+
+/* Eventfd that the GLib main loop should watch with G_IO_IN. Wakes
+ * whenever a context-resolve sub-result is queued. Caller MUST NOT
+ * close it. */
+int   gjsify_rolldown_session_context_response_fd (BundleSession *session);
+
+/* Drain one context-resolve sub-result as JSON
+ * `{childId, id?, external?, error?}`. Returns NULL when empty. */
+char *gjsify_rolldown_session_next_context_response (BundleSession *session,
+                                                     size_t        *out_len);
+
+/* ----------------------------------------------------------------- */
+/* Phase B.4 — bytes-payload side-channel for transform's source code. */
+/* ----------------------------------------------------------------- */
+
+/* Drain the request-payload bytes the Rust side stashed for @req_id
+ * (transform's source code). Returns NULL when empty / already
+ * consumed. Caller frees the returned buffer via
+ * gjsify_rolldown_session_free_payload(buf, len). */
+uint8_t *gjsify_rolldown_session_take_request_payload (BundleSession *session,
+                                                       uint64_t       req_id,
+                                                       size_t        *out_len);
+
+/* Stash bytes the JS handler wants Rust to read after respond() — the
+ * transform hook's output code. Returns true on success. */
+bool     gjsify_rolldown_session_set_response_payload  (BundleSession *session,
+                                                        uint64_t       req_id,
+                                                        const uint8_t *bytes,
+                                                        size_t         bytes_len);
+
+/* Free a buffer returned by take_request_payload. */
+void     gjsify_rolldown_session_free_payload          (uint8_t       *buf,
+                                                        size_t         len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GJSIFY_ROLLDOWN_H */