@velox0/cerver 0.4.3 → 0.5.0

package/lib/commands/run.js

@@ -3,12 +3,19 @@
 const { execFileSync } = require("child_process");
 const path = require("path");
 const fs = require("fs");
+const { findProjectRoot } = require("../config");
 
 /**
  * Run the compiled binary from dist/.
  */
 function run(opts) {
-  const projectDir = process.cwd();
+  const projectDir = findProjectRoot();
+  if (!projectDir) {
+    console.log("Not a cerver project");
+    process.exit(1);
+  }
+  process.chdir(projectDir);
+
   const binaryPath = path.join(projectDir, "dist", "server");
 
   if (!fs.existsSync(binaryPath)) {

package/lib/compiler/compile.js

@@ -45,12 +45,17 @@ function supportsFlag(cc, flag) {
  */
 function compile(distDir, runtimeDir, opts) {
   const cc = detectCompiler();
-  const serverC = path.join(distDir, "server.c");
   const outputBin = path.join(distDir, "server");
 
-  if (!fs.existsSync(serverC)) {
+  /* Collect all generated source files from distDir */
+  const generatedSources = fs
+    .readdirSync(distDir)
+    .filter((f) => f.endsWith(".c"))
+    .map((f) => path.join(distDir, f));
+
+  if (generatedSources.length === 0) {
     throw new Error(
-      `cerver: generated source not found at ${serverC}`
+      `cerver: no generated C source files found in ${distDir}`
     );
   }
 
@@ -68,7 +73,7 @@ function compile(distDir, runtimeDir, opts) {
     "-Wno-unused-parameter",
     "-o",
     outputBin,
-    serverC,
+    ...generatedSources,
     ...runtimeSources,
     `-I${runtimeDir}`,
     "-lpthread",

package/lib/config.js

@@ -53,4 +53,23 @@ function loadConfig(projectDir) {
   return config;
 }
 
-module.exports = { loadConfig, DEFAULTS };
+function findProjectRoot(startDir = process.cwd()) {
+  let currentDir = startDir;
+
+  while (true) {
+    if (fs.existsSync(path.join(currentDir, "cerver.config.js"))) {
+      return currentDir;
+    }
+
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+
+  return null;
+}
+
+module.exports = { loadConfig, findProjectRoot, DEFAULTS };
+

package/lib/parser/discover.js

@@ -4,15 +4,15 @@ const fs = require("fs");
 const path = require("path");
 
 /**
- * Discover route files under app/routes/ and map them to URL paths.
+ * Discover route files under routes/ and map them to URL paths.
  *
  * File-based routing convention:
- *   app/routes/index.js      → /
- *   app/routes/page.js       → /page
- *   app/routes/group/item.js → /group/item
- *   app/routes/item/[id].js  → /item/:id
+ *   routes/index.js      → /
+ *   routes/page.js       → /page
+ *   routes/group/item.js → /group/item
+ *   routes/item/[id].js  → /item/:id
  *
- * @param {string} routesDir - Absolute path to app/routes/
+ * @param {string} routesDir - Absolute path to routes/
  * @returns {Array<{ filePath: string, urlPath: string }>}
  */
 function discoverRoutes(routesDir) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velox0/cerver",
-  "version": "0.4.3",
+  "version": "0.5.0",
   "description": "Compile restricted JavaScript server logic into optimized native C binaries",
   "main": "bin/cerver.js",
   "bin": {

package/runtime/cerver.h

@@ -238,7 +238,7 @@ struct cerver_server {
   cerver_worker_t* workers;
 
   /* Route trie for radix/trie-based routing */
-  void*            route_trie;
+  void* route_trie;
 };
 
 /* Server lifecycle */
@@ -269,7 +269,8 @@ int cerver_write_response(int fd, const cerver_response_t* res, int keepalive);
 int               cerver_route_match(const cerver_route_t* route, cerver_request_t* req);
 cerver_handler_fn cerver_dispatch(cerver_server_t* srv, cerver_request_t* req);
 void*             cerver_trie_create(void);
-void              cerver_trie_insert(void* trie, const char* pattern, const char* method, cerver_handler_fn handler);
+void              cerver_trie_insert(void* trie, const char* pattern, const char* method,
+                                     cerver_handler_fn handler);
 void              cerver_trie_free(void* trie);
 
 /* ------------------------------------------------------------------ */

package/runtime/http_writer.c

@@ -25,7 +25,7 @@ static ssize_t cerver_sendfile(int out_fd, int in_fd, off_t offset, size_t count
 #include <sys/socket.h>
 static ssize_t cerver_sendfile(int out_fd, int in_fd, off_t offset, size_t count) {
   off_t len = (off_t)count;
-  int res = sendfile(in_fd, out_fd, offset, &len, NULL, 0);
+  int   res = sendfile(in_fd, out_fd, offset, &len, NULL, 0);
   if (res == 0) {
     return (ssize_t)len;
   }
@@ -35,8 +35,8 @@ static ssize_t cerver_sendfile(int out_fd, int in_fd, off_t offset, size_t count
   /* Fallback to read-write copy if not a socket or unsupported on this descriptor type */
   char buf[8192];
   if (lseek(in_fd, offset, SEEK_SET) == -1) return -1;
-  size_t to_read = count > sizeof(buf) ? sizeof(buf) : count;
-  ssize_t n_read = read(in_fd, buf, to_read);
+  size_t  to_read = count > sizeof(buf) ? sizeof(buf) : count;
+  ssize_t n_read  = read(in_fd, buf, to_read);
   if (n_read <= 0) return n_read;
 
   size_t written = 0;
@@ -54,8 +54,8 @@ static ssize_t cerver_sendfile(int out_fd, int in_fd, off_t offset, size_t count
 static ssize_t cerver_sendfile(int out_fd, int in_fd, off_t offset, size_t count) {
   char buf[8192];
   if (lseek(in_fd, offset, SEEK_SET) == -1) return -1;
-  size_t to_read = count > sizeof(buf) ? sizeof(buf) : count;
-  ssize_t n_read = read(in_fd, buf, to_read);
+  size_t  to_read = count > sizeof(buf) ? sizeof(buf) : count;
+  ssize_t n_read  = read(in_fd, buf, to_read);
   if (n_read <= 0) return n_read;
 
   size_t written = 0;
@@ -156,7 +156,7 @@ int cerver_write_response(int fd, const cerver_response_t* res, int keepalive) {
    */
   if (res->_body_owned == 3) {
     /* Send header first */
-    size_t header_total = (size_t)hlen;
+    size_t header_total   = (size_t)hlen;
     size_t header_written = 0;
     while (header_written < header_total) {
       ssize_t n = write(fd, header + header_written, header_total - header_written);
@@ -169,7 +169,7 @@ int cerver_write_response(int fd, const cerver_response_t* res, int keepalive) {
 
     /* Zero-copy body sending via sendfile(2) */
     size_t body_total = res->body_len;
-    size_t body_sent = 0;
+    size_t body_sent  = 0;
     while (body_sent < body_total) {
       ssize_t n = cerver_sendfile(fd, res->_file_fd, (off_t)body_sent, body_total - body_sent);
       if (n < 0) {
@@ -183,7 +183,7 @@ int cerver_write_response(int fd, const cerver_response_t* res, int keepalive) {
     if ((size_t)hlen + res->body_len <= sizeof(header)) {
       /* Small response optimization: copy body into header buffer and send in one syscall */
       memcpy(header + hlen, res->body, res->body_len);
-      size_t total = (size_t)hlen + res->body_len;
+      size_t total   = (size_t)hlen + res->body_len;
       size_t written = 0;
       while (written < total) {
         ssize_t n = write(fd, header + written, total - written);

package/runtime/router.c

@@ -108,9 +108,9 @@ int cerver_route_match(const cerver_route_t* route, cerver_request_t* req) {
   const char* pp = pattern; /* pattern pointer */
   const char* rp = path;    /* request path pointer */
 
-  int saved_params = req->params_count;
+  int   saved_params = req->params_count;
   char* param_slashes[CERVER_MAX_PARAMS];
-  int param_slash_count = 0;
+  int   param_slash_count = 0;
 
   /* Skip leading '/' */
   if (*pp == '/') pp++;
@@ -186,18 +186,18 @@ typedef struct trie_node trie_node_t;
 
 struct trie_node {
   char* segment;
-  int is_param;
+  int   is_param;
   char* param_name;
 
   struct {
-    const char* method;
+    const char*       method;
     cerver_handler_fn handler;
   } handlers[16];
   int handler_count;
 
   trie_node_t** children;
-  int children_count;
-  int children_cap;
+  int           children_count;
+  int           children_cap;
 };
 
 void* cerver_trie_create(void) {
@@ -210,17 +210,18 @@ static trie_node_t* trie_create_node(const char* segment, size_t len) {
   if (node && segment) {
     node->segment = trie_strndup(segment, len);
     if (node->segment[0] == ':') {
-      node->is_param = 1;
+      node->is_param   = 1;
       node->param_name = trie_strndup(node->segment + 1, len - 1);
     }
   }
   return node;
 }
 
-void cerver_trie_insert(void* trie, const char* pattern, const char* method, cerver_handler_fn handler) {
+void cerver_trie_insert(void* trie, const char* pattern, const char* method,
+                        cerver_handler_fn handler) {
   if (!trie) return;
   trie_node_t* curr = (trie_node_t*)trie;
-  const char* p = pattern;
+  const char*  p    = pattern;
   while (*p == '/') p++;
 
   while (*p) {
@@ -246,7 +247,7 @@ void cerver_trie_insert(void* trie, const char* pattern, const char* method, cer
       child = trie_create_node(seg_start, len);
       if (curr->children_count >= curr->children_cap) {
         curr->children_cap = curr->children_cap == 0 ? 4 : curr->children_cap * 2;
-        curr->children = realloc(curr->children, curr->children_cap * sizeof(trie_node_t*));
+        curr->children     = realloc(curr->children, curr->children_cap * sizeof(trie_node_t*));
       }
       curr->children[curr->children_count++] = child;
     }
@@ -257,7 +258,7 @@ void cerver_trie_insert(void* trie, const char* pattern, const char* method, cer
 
   // Add handler to leaf
   if (curr->handler_count < 16) {
-    curr->handlers[curr->handler_count].method = method;
+    curr->handlers[curr->handler_count].method  = method;
     curr->handlers[curr->handler_count].handler = handler;
     curr->handler_count++;
   }
@@ -275,7 +276,8 @@ void cerver_trie_free(void* trie) {
   free(node);
 }
 
-static int trie_match_recursive(trie_node_t* node, const char* path, cerver_request_t* req, cerver_handler_fn* out_handler, int param_start_idx) {
+static int trie_match_recursive(trie_node_t* node, const char* path, cerver_request_t* req,
+                                cerver_handler_fn* out_handler, int param_start_idx) {
   // Skip leading slashes
   while (*path == '/') path++;
 
@@ -283,7 +285,7 @@ static int trie_match_recursive(trie_node_t* node, const char* path, cerver_requ
     // Check if node has a handler for req->method
     for (int i = 0; i < node->handler_count; i++) {
       if (strcmp(node->handlers[i].method, req->method) == 0) {
-        *out_handler = node->handlers[i].handler;
+        *out_handler      = node->handlers[i].handler;
         req->params_count = param_start_idx;
         return 1;
       }
@@ -313,7 +315,7 @@ static int trie_match_recursive(trie_node_t* node, const char* path, cerver_requ
     trie_node_t* child = node->children[i];
     if (child->is_param) {
       if (param_start_idx < CERVER_MAX_PARAMS) {
-        req->params[param_start_idx].key = child->param_name;
+        req->params[param_start_idx].key   = child->param_name;
         req->params[param_start_idx].value = seg_start;
       }
       if (trie_match_recursive(child, path, req, out_handler, param_start_idx + 1)) {
@@ -340,7 +342,7 @@ cerver_handler_fn cerver_dispatch(cerver_server_t* srv, cerver_request_t* req) {
   if (!srv->route_trie) return NULL;
 
   cerver_handler_fn handler = NULL;
-  req->params_count = 0;
+  req->params_count         = 0;
   if (trie_match_recursive((trie_node_t*)srv->route_trie, req->path, req, &handler, 0)) {
     // NUL-terminate extracted values in-place inside req->path
     for (int i = 0; i < req->params_count; i++) {

package/runtime/server.c

@@ -771,6 +771,22 @@ int cerver_listen(cerver_server_t* srv) {
   printf("cerver: %d acceptor(s), %d connection workers, keep-alive max %d req/conn\n",
          acceptor_count, pool_size, CERVER_KEEPALIVE_MAX);
 
+  for (int i = 0; i < srv->route_count; i++) {
+    const char* method = srv->routes[i].method;
+    const char* color  = "\x1B[35m";
+    if (strcmp(method, "GET") == 0) {
+      color = "\x1B[32m";
+    } else if (strcmp(method, "POST") == 0) {
+      color = "\x1B[33m";
+    } else if (strcmp(method, "PUT") == 0) {
+      color = "\x1B[36m";
+    } else if (strcmp(method, "DELETE") == 0) {
+      color = "\x1B[31m";
+    }
+    printf("  → Mapped {%s, %s%s\x1B[0m} route\n", srv->routes[i].pattern, color, method);
+  }
+  fflush(stdout);
+
   release_acceptors();
 
   pthread_attr_destroy(&attr);

package/runtime/static.c

@@ -85,6 +85,64 @@ static void add_cache_headers(cerver_response_t* res, const char* path) {
   }
 }
 
+/* ------------------------------------------------------------------ */
+/*  Helper to resolve fallback paths for directory/clean-URL routes.  */
+/*  - "/" -> "/index.html"                                            */
+/*  - "/page" or "/page/" -> "/page/page.html"                        */
+/* ------------------------------------------------------------------ */
+
+static void get_fallback_path(const char* path, char* out, size_t out_len) {
+  if (strcmp(path, "/") == 0 || strcmp(path, "") == 0) {
+    snprintf(out, out_len, "/index.html");
+    return;
+  }
+
+  size_t len = strlen(path);
+  while (len > 0 && path[len - 1] == '/') {
+    len--;
+  }
+
+  if (len == 0) {
+    snprintf(out, out_len, "/index.html");
+    return;
+  }
+
+  int last_slash = -1;
+  for (int i = (int)len - 1; i >= 0; i--) {
+    if (path[i] == '/') {
+      last_slash = i;
+      break;
+    }
+  }
+
+  size_t segment_len = len - (last_slash + 1);
+  if (segment_len == 0) {
+    snprintf(out, out_len, "/index.html");
+    return;
+  }
+
+  /* Extract the prefix and segment safely */
+  char prefix[1024];
+  if (len < sizeof(prefix)) {
+    memcpy(prefix, path, len);
+    prefix[len] = '\0';
+  } else {
+    snprintf(out, out_len, "/index.html");
+    return;
+  }
+
+  char segment[256];
+  if (segment_len < sizeof(segment)) {
+    memcpy(segment, path + last_slash + 1, segment_len);
+    segment[segment_len] = '\0';
+  } else {
+    snprintf(out, out_len, "/index.html");
+    return;
+  }
+
+  snprintf(out, out_len, "%s/%s.html", prefix, segment);
+}
+
 /* ------------------------------------------------------------------ */
 /*  Serve from embedded assets — hash-accelerated lookup              */
 /* ------------------------------------------------------------------ */
@@ -110,19 +168,15 @@ static int serve_embedded(cerver_server_t* srv, cerver_request_t* req, cerver_re
     }
   }
 
-  /* Try with /index.html appended (for directory-like paths) */
+  /* Try with fallback path (for directory-like paths) */
   if (!found) {
-    char   index_path[CERVER_MAX_PATH];
-    size_t plen = strlen(path);
-    if (plen > 0 && path[plen - 1] == '/') {
-      snprintf(index_path, sizeof(index_path), "%sindex.html", path);
-    } else {
-      snprintf(index_path, sizeof(index_path), "%s/index.html", path);
-    }
+    char fallback_path[CERVER_MAX_PATH];
+    get_fallback_path(path, fallback_path, sizeof(fallback_path));
 
-    uint32_t idx_hash = fnv1a(index_path);
+    uint32_t idx_hash = fnv1a(fallback_path);
     for (int i = 0; i < srv->asset_count; i++) {
-      if (fnv1a(srv->assets[i].path) == idx_hash && strcmp(srv->assets[i].path, index_path) == 0) {
+      if (fnv1a(srv->assets[i].path) == idx_hash &&
+          strcmp(srv->assets[i].path, fallback_path) == 0) {
         found = &srv->assets[i];
         break;
       }
@@ -168,10 +222,12 @@ static int serve_filesystem(cerver_server_t* srv, cerver_request_t* req, cerver_
   char full_path[CERVER_MAX_PATH * 2];
   snprintf(full_path, sizeof(full_path), "%s%s", srv->public_dir, path);
 
-  /* Check if it's a directory — try index.html */
+  /* Check if it's a directory — try fallback path */
   struct stat st;
   if (stat(full_path, &st) == 0 && S_ISDIR(st.st_mode)) {
-    snprintf(full_path, sizeof(full_path), "%s%s/index.html", srv->public_dir, path);
+    char fallback_path[CERVER_MAX_PATH];
+    get_fallback_path(path, fallback_path, sizeof(fallback_path));
+    snprintf(full_path, sizeof(full_path), "%s%s", srv->public_dir, fallback_path);
     if (stat(full_path, &st) != 0) return -1;
   }
 

package/runtime/tests/runtime_tests.c

@@ -288,9 +288,9 @@ static void test_static_embedded_index_fallback(void) {
   cerver_server_t srv;
   cerver_init(&srv, 8080, 1);
 
-  static const unsigned char data[] = "docs";
+  static const unsigned char data[] = "about";
   cerver_asset_t             assets[1];
-  assets[0].path        = "/docs/index.html";
+  assets[0].path        = "/about/about.html";
   assets[0].mime_type   = "text/html";
   assets[0].data        = data;
   assets[0].data_len    = sizeof(data) - 1;
@@ -305,13 +305,91 @@ static void test_static_embedded_index_fallback(void) {
   memset(&req, 0, sizeof(req));
   memset(&res, 0, sizeof(res));
   strcpy(req.method, "GET");
-  strcpy(req.path, "/docs/");
+  strcpy(req.path, "/about/");
 
   MU_ASSERT_EQ_INT(0, cerver_serve_static(&srv, &req, &res));
   MU_ASSERT(res.body == (const char*)data);
   MU_ASSERT_STREQ("text/html", res.content_type);
 }
 
+static void test_static_filesystem_directory_fallback(void) {
+  char  dir_template[] = "/tmp/cerver-test-XXXXXX";
+  char* dir            = mkdtemp(dir_template);
+  MU_ASSERT(dir != NULL);
+
+  /* Create public/index.html (maps to /) */
+  char file_path[PATH_MAX];
+  snprintf(file_path, sizeof(file_path), "%s/index.html", dir);
+  MU_ASSERT_EQ_INT(0, write_file(file_path, "root index", 10));
+
+  /* Create public/about/about.html (maps to /about or /about/) */
+  char sub_dir[PATH_MAX];
+  snprintf(sub_dir, sizeof(sub_dir), "%s/about", dir);
+  MU_ASSERT_EQ_INT(0, mkdir(sub_dir, 0700));
+
+  char file_path2[PATH_MAX];
+  snprintf(file_path2, sizeof(file_path2), "%s/about/about.html", dir);
+  MU_ASSERT_EQ_INT(0, write_file(file_path2, "about content", 13));
+
+  /* Create public/about/index.html (should NOT map to /about, since index.html under subdirectory
+   * doesn't alias) */
+  char file_path3[PATH_MAX];
+  snprintf(file_path3, sizeof(file_path3), "%s/about/index.html", dir);
+  MU_ASSERT_EQ_INT(0, write_file(file_path3, "about index", 11));
+
+  cerver_server_t srv;
+  cerver_init(&srv, 8080, 1);
+  cerver_set_public_dir(&srv, dir);
+
+  /* Test / -> index.html fallback */
+  {
+    cerver_request_t  req;
+    cerver_response_t res;
+    memset(&req, 0, sizeof(req));
+    memset(&res, 0, sizeof(res));
+    strcpy(req.method, "GET");
+    strcpy(req.path, "/");
+
+    MU_ASSERT_EQ_INT(0, cerver_serve_static(&srv, &req, &res));
+    MU_ASSERT_EQ_SIZE(10, res.body_len);
+    if (res._body_owned == 3 && res._file_fd >= 0) close(res._file_fd);
+  }
+
+  /* Test /about -> about/about.html fallback */
+  {
+    cerver_request_t  req;
+    cerver_response_t res;
+    memset(&req, 0, sizeof(req));
+    memset(&res, 0, sizeof(res));
+    strcpy(req.method, "GET");
+    strcpy(req.path, "/about");
+
+    MU_ASSERT_EQ_INT(0, cerver_serve_static(&srv, &req, &res));
+    MU_ASSERT_EQ_SIZE(13, res.body_len);
+    if (res._body_owned == 3 && res._file_fd >= 0) close(res._file_fd);
+  }
+
+  /* Test /about/ -> about/about.html fallback */
+  {
+    cerver_request_t  req;
+    cerver_response_t res;
+    memset(&req, 0, sizeof(req));
+    memset(&res, 0, sizeof(res));
+    strcpy(req.method, "GET");
+    strcpy(req.path, "/about/");
+
+    MU_ASSERT_EQ_INT(0, cerver_serve_static(&srv, &req, &res));
+    MU_ASSERT_EQ_SIZE(13, res.body_len);
+    if (res._body_owned == 3 && res._file_fd >= 0) close(res._file_fd);
+  }
+
+  unlink(file_path);
+  unlink(file_path2);
+  unlink(file_path3);
+  rmdir(sub_dir);
+  rmdir(dir);
+}
+
 static void test_static_filesystem_small(void) {
   char  dir_template[] = "/tmp/cerver-test-XXXXXX";
   char* dir            = mkdtemp(dir_template);
@@ -343,7 +421,7 @@ static void test_static_filesystem_small(void) {
   MU_ASSERT_EQ_INT(0, cerver_write_response(fds[1], &res, 1));
   close(fds[1]);
 
-  char out[1024];
+  char    out[1024];
   ssize_t n = read_all(fds[0], out, sizeof(out));
   MU_ASSERT(n > 0);
   close(fds[0]);
@@ -395,7 +473,7 @@ static void test_static_filesystem_large(void) {
   MU_ASSERT_EQ_INT(0, cerver_write_response(fds[1], &res, 1));
   close(fds[1]);
 
-  char out[35000];
+  char    out[35000];
   ssize_t n = read_all(fds[0], out, sizeof(out));
   MU_ASSERT(n > 0);
   close(fds[0]);
@@ -457,6 +535,7 @@ int main(void) {
   mu_run("static_embedded_index_fallback", test_static_embedded_index_fallback);
   mu_run("static_filesystem_small", test_static_filesystem_small);
   mu_run("static_filesystem_large", test_static_filesystem_large);
+  mu_run("static_filesystem_directory_fallback", test_static_filesystem_directory_fallback);
   mu_run("static_rejects_unsafe_path", test_static_rejects_unsafe_path);
   mu_run("stat_cache_store_lookup", test_stat_cache_store_lookup);
   mu_run("cerver_init_fields", test_cerver_init_fields);

package/.github/workflows/ci.yml

@@ -1,35 +0,0 @@
-name: CI
-
-on:
-  push:
-  pull_request:
-
-jobs:
-  tests:
-    name: Tests
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v6
-        with:
-          version: 10
-          run_install: false
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v6
-        with:
-          node-version: 24
-          cache: pnpm
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Run runtime tests
-        run: make test-runtime
-
-      - name: Run JS tests
-        run: pnpm test

package/.github/workflows/publish.yml

@@ -1,50 +0,0 @@
-name: Publish package
-
-on:
-  push:
-    tags:
-      - "v*"
-  workflow_dispatch:
-
-permissions:
-  contents: write
-  id-token: write
-
-jobs:
-  publish:
-    name: Publish to npm
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v6
-        with:
-          version: 10
-          run_install: false
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v6
-        with:
-          node-version: 24
-          registry-url: https://registry.npmjs.org
-          cache: pnpm
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Run runtime tests
-        run: make test-runtime
-
-      - name: Run tests
-        run: pnpm test
-
-      - name: Verify package contents
-        run: npm pack --dry-run
-
-      - name: Publish to npm
-        run: npm publish --access public --provenance
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}