xbintsc 0.5.20 → 0.5.21

package/runtime/ext_gui/svg.cpp

@@ -3,9 +3,9 @@
  *
  * The heavy lifting is the vendored NanoSVG library (`nanosvg.h` +
  * `nanosvgrast.h`, zlib licence, fetched verbatim). This file is only the glue:
- * path detection, a parsed-document cache and the scale-to-fit call. NanoSVG
- * emits straight (non-premultiplied) RGBA8, which is exactly the `Image`
- * layout the rest of the engine expects.
+ * path detection, parsed-document caches (per file and per inline markup) and
+ * the scale-to-fit call. NanoSVG emits straight (non-premultiplied) RGBA8,
+ * which is exactly the `Image` layout the rest of the engine expects.
  */
 
 #include "svg.h"
@@ -31,6 +31,7 @@
 
 #include <algorithm>
 #include <cctype>
+#include <cstdint>
 #include <cstdio>
 #include <fstream>
 #include <string>
@@ -89,16 +90,13 @@ NSVGrasterizer *&rasterizer() {
   return value;
 }
 
-/** Parse `path` once and remember the result (including failures, so a missing
- * file is not retried every frame). */
-NSVGimage *parseCached(const std::string &path) {
-  auto &cache = parsedCache();
-  auto found = cache.find(path);
-  if (found != cache.end()) return found->second;
-  NSVGimage *image = nsvgParseFromFile(path.c_str(), "px", 96.0f);
-  cache.emplace(path, image);
-  return image;
-}
+/** One parsed inline-SVG document in the markup cache. `stamp` is the last use
+ * (see `parseMarkup`); `image` is null when the markup failed to parse so a
+ * broken document is not retried on every layout. */
+struct MarkupDocument {
+  NSVGimage *image = nullptr;
+  uint64_t stamp = 0;
+};
 
 float intrinsicWidth(const NSVGimage *image) {
   return image->width > 0.0f ? image->width : kDefaultWidth;
@@ -108,33 +106,53 @@ float intrinsicHeight(const NSVGimage *image) {
   return image->height > 0.0f ? image->height : kDefaultHeight;
 }
 
-}  // namespace
+/** Inline SVG markup is authored in the document and can change at any time, so
+ * unlike the per-path file cache this one is bounded: a script that animates an
+ * inline `<svg>` attribute every frame would otherwise add one parse (and its
+ * NSVGimage tree) per frame forever. */
+constexpr size_t kMaxMarkupDocuments = 256;
 
-bool xt_svg_is_svg(const std::string &path) {
-  auto &cache = detectCache();
-  auto found = cache.find(path);
-  if (found != cache.end()) return found->second;
-  bool result = hasSvgExtension(path) || prefixLooksLikeSvg(path);
-  cache.emplace(path, result);
-  return result;
+std::unordered_map<std::string, MarkupDocument> &markupCache() {
+  static std::unordered_map<std::string, MarkupDocument> cache;
+  return cache;
 }
 
-bool xt_svg_size(const std::string &path, int *width, int *height) {
-  NSVGimage *image = parseCached(path);
-  if (image == nullptr) return false;
-  float w = intrinsicWidth(image);
-  float h = intrinsicHeight(image);
-  if (w <= 0.0f || h <= 0.0f) return false;
-  if (width != nullptr) *width = (int)(w + 0.5f);
-  if (height != nullptr) *height = (int)(h + 0.5f);
-  return true;
+uint64_t nextStamp() {
+  static uint64_t counter = 0;
+  return ++counter;
 }
 
-bool xt_svg_render(const std::string &path, int width, int height, Image *out) {
-  if (out == nullptr) return false;
-  NSVGimage *image = parseCached(path);
-  if (image == nullptr) return false;
+/** Parse an inline SVG document once and remember the result. Evicts the
+ * least-recently-used entry when the table is full; nothing outside this module
+ * keeps an `NSVGimage*`, so a parse can always be dropped safely. */
+NSVGimage *parseMarkup(const std::string &markup) {
+  auto &cache = markupCache();
+  uint64_t stamp = nextStamp();
+  auto found = cache.find(markup);
+  if (found != cache.end()) {
+    found->second.stamp = stamp;
+    return found->second.image;
+  }
+  if (cache.size() >= kMaxMarkupDocuments) {
+    auto oldest = cache.begin();
+    for (auto it = cache.begin(); it != cache.end(); ++it) {
+      if (it->second.stamp < oldest->second.stamp) oldest = it;
+    }
+    if (oldest->second.image != nullptr) nsvgDelete(oldest->second.image);
+    cache.erase(oldest);
+  }
+  /* NanoSVG's XML parser NUL-terminates tags in place, so it needs its own
+   * mutable copy of the document. */
+  std::string document = markup;
+  NSVGimage *image = nsvgParse(document.data(), "px", 96.0f);
+  cache.emplace(markup, MarkupDocument{image, stamp});
+  return image;
+}
 
+/** Rasterise a parsed document at `width` x `height` device pixels, at the
+ * larger axis scale so neither axis is under-sampled. Returns false when the
+ * size is unusable or the rasteriser cannot be created. */
+bool rasterize(NSVGimage *image, int width, int height, Image *out) {
   float source_width = intrinsicWidth(image);
   float source_height = intrinsicHeight(image);
   int target_width = width > 0 ? width : (int)(source_width + 0.5f);
@@ -143,11 +161,6 @@ bool xt_svg_render(const std::string &path, int width, int height, Image *out) {
   target_width = std::min(target_width, kMaxDimension);
   target_height = std::min(target_height, kMaxDimension);
 
-  /* Rasterise at the source aspect ratio, at the larger of the two axis scales
-   * (so neither axis is under-sampled), then let the quad stretch the texture
-   * to the box — exactly how a bitmap would behave under CSS `object-fit:
-   * fill`. The common case (layout preserved the aspect ratio) makes this equal
-   * to the requested size. */
   float scale = std::max((float)target_width / source_width, (float)target_height / source_height);
   scale = std::min(scale, (float)kMaxDimension / source_width);
   scale = std::min(scale, (float)kMaxDimension / source_height);
@@ -167,12 +180,82 @@ bool xt_svg_render(const std::string &path, int width, int height, Image *out) {
   return true;
 }
 
+/** Parse `path` once and remember the result (including failures, so a missing
+ * file is not retried every frame). */
+NSVGimage *parseCached(const std::string &path) {
+  auto &cache = parsedCache();
+  auto found = cache.find(path);
+  if (found != cache.end()) return found->second;
+  NSVGimage *image = nsvgParseFromFile(path.c_str(), "px", 96.0f);
+  cache.emplace(path, image);
+  return image;
+}
+
+}  // namespace
+
+bool xt_svg_is_svg(const std::string &path) {
+  auto &cache = detectCache();
+  auto found = cache.find(path);
+  if (found != cache.end()) return found->second;
+  bool result = hasSvgExtension(path) || prefixLooksLikeSvg(path);
+  cache.emplace(path, result);
+  return result;
+}
+
+bool xt_svg_size(const std::string &path, int *width, int *height) {
+  NSVGimage *image = parseCached(path);
+  if (image == nullptr) return false;
+  float w = intrinsicWidth(image);
+  float h = intrinsicHeight(image);
+  if (w <= 0.0f || h <= 0.0f) return false;
+  if (width != nullptr) *width = (int)(w + 0.5f);
+  if (height != nullptr) *height = (int)(h + 0.5f);
+  return true;
+}
+
+bool xt_svg_render(const std::string &path, int width, int height, Image *out) {
+  if (out == nullptr) return false;
+  NSVGimage *image = parseCached(path);
+  if (image == nullptr) return false;
+  return rasterize(image, width, height, out);
+}
+
+bool xt_svg_markup_size(const std::string &markup, int *width, int *height) {
+  NSVGimage *image = parseMarkup(markup);
+  if (image == nullptr) return false;
+  float w = intrinsicWidth(image);
+  float h = intrinsicHeight(image);
+  if (w <= 0.0f || h <= 0.0f) return false;
+  if (width != nullptr) *width = (int)(w + 0.5f);
+  if (height != nullptr) *height = (int)(h + 0.5f);
+  return true;
+}
+
+bool xt_svg_markup_render(const std::string &markup, int width, int height, Image *out) {
+  if (out == nullptr) return false;
+  NSVGimage *image = parseMarkup(markup);
+  if (image == nullptr) return false;
+  return rasterize(image, width, height, out);
+}
+
+int xt_svg_markup_shapes(const std::string &markup) {
+  NSVGimage *image = parseMarkup(markup);
+  if (image == nullptr) return 0;
+  int count = 0;
+  for (const NSVGshape *shape = image->shapes; shape != nullptr; shape = shape->next) count++;
+  return count;
+}
+
 void xt_svg_shutdown() {
   for (auto &entry : parsedCache()) {
     if (entry.second != nullptr) nsvgDelete(entry.second);
   }
   parsedCache().clear();
   detectCache().clear();
+  for (auto &entry : markupCache()) {
+    if (entry.second.image != nullptr) nsvgDelete(entry.second.image);
+  }
+  markupCache().clear();
   if (rasterizer() != nullptr) {
     nsvgDeleteRasterizer(rasterizer());
     rasterizer() = nullptr;

package/runtime/ext_gui/svg.h

@@ -9,9 +9,10 @@
  * (`nanosvg.h` + `nanosvgrast.h`) — the same class of low-level, third-party
  * image library `stb_image` is (see doc/gui.md).
  *
- * Only *files* are handled: `<img src="logo.svg">`. Inline `<svg>` trees in a
- * document are still ordinary unknown elements to the HTML parser and generate
- * no boxes.
+ * Both SVG *files* (`<img src="logo.svg">`) and inline `<svg>` trees go through
+ * this module: an inline element's DOM subtree is serialized into a document by
+ * `inline_svg.{h,cpp}` and parsed with the markup entry points below, so both
+ * kinds produce the same RGBA8 `Image` at the drawn device size.
  */
 #ifndef XT_GUI_SVG_H
 #define XT_GUI_SVG_H
@@ -30,6 +31,16 @@ bool xt_svg_is_svg(const std::string &path);
  * false when the file is missing or cannot be parsed. Cached per path. */
 bool xt_svg_size(const std::string &path, int *width, int *height);
 
+/** The same two operations for an SVG *document string* rather than a file:
+ * the markup of an inline `<svg>` subtree (see `inline_svg.h`). The parse is
+ * cached by content (least-recently-used, so an animated document cannot grow
+ * the cache without bound); each rasterisation is fresh. */
+bool xt_svg_markup_size(const std::string &markup, int *width, int *height);
+bool xt_svg_markup_render(const std::string &markup, int width, int height, Image *out);
+
+/** Number of shapes NanoSVG parsed out of `markup` (diagnostics/tests). */
+int xt_svg_markup_shapes(const std::string &markup);
+
 /** Rasterise `path` to RGBA8. `width`/`height` are the requested pixel size;
  * when either is `<= 0` the intrinsic SVG size is used. The viewBox is scaled
  * uniformly at the larger of the two axis scales (preserving the SVG's aspect

package/runtime/ext_gui/window.cpp

@@ -12,6 +12,7 @@
 
 #include <algorithm>
 
+#include "inline_svg.h"
 #include "paint.h"
 #include "text.h"
 
@@ -216,6 +217,32 @@ static xt_value win_paint_count(xt_value self, xt_value env, int32_t argc, xt_va
   return xt_number((double)list.rects.size());
 }
 
+/** Diagnostic/test hook: the serialized SVG document of the first `<svg>`
+ * element matching `selector`, plus the intrinsic size and shape count the
+ * NanoSVG parse yields. Returns `undefined` when there is no such element. */
+static xt_value win_inline_svg(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  XtGuiWindow *win = xt_gui_window_from_this(self);
+  if (win == nullptr || win->document == nullptr || argc < 1) return XT_UNDEFINED;
+  xt_gui_flush_dom(win);
+  xt_value selectorValue = xt_to_string(xt_arg(argc, argv, 0));
+  const char *selector = xt_string_data(selectorValue);
+  if (selector == nullptr) return XT_UNDEFINED;
+  const xtgui::Node *node = win->document->querySelector(selector);
+  if (!xtgui::xt_inline_svg_is_root(node)) return XT_UNDEFINED;
+  std::string markup = xtgui::xt_inline_svg_serialize(node);
+  int width = 0;
+  int height = 0;
+  xtgui::xt_svg_markup_size(markup, &width, &height);
+  xt_value object = xt_object_new();
+  xt_object_set(object, xt_string_from_cstr("markup"), xt_string_from_cstr(markup.c_str()));
+  xt_object_set(object, xt_string_from_cstr("width"), xt_number(width));
+  xt_object_set(object, xt_string_from_cstr("height"), xt_number(height));
+  xt_object_set(object, xt_string_from_cstr("shapes"),
+                xt_number(xtgui::xt_svg_markup_shapes(markup)));
+  return object;
+}
+
 /** Diagnostic/test hook: advance the CSS transition clock by `ms`. */
 static xt_value win_advance(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
   (void)env;
@@ -527,6 +554,7 @@ xt_value xt_gui_window_proto(void) {
   define_method(proto, "setBackground", (void *)win_set_background);
   define_method(proto, "paintList", (void *)win_paint_list);
   define_method(proto, "paintCount", (void *)win_paint_count);
+  define_method(proto, "inlineSvg", (void *)win_inline_svg);
   define_method(proto, "advance", (void *)win_advance);
   define_method(proto, "measureText", (void *)win_measure_text);
   define_method(proto, "fontMetrics", (void *)win_font_metrics);

package/runtime/ext_node/fs/async_api.c

@@ -0,0 +1,314 @@
+/*
+ * Main-thread argument marshalling for asynchronous `fs/promises`.
+ *
+ * Each export copies whatever it needs from the JavaScript values (paths,
+ * encodings, buffers, options) into a job, then submits it. The blocking half
+ * runs on a worker; the promise is settled later on the reactor thread. This is
+ * also where the non-I/O argument parsing matches the synchronous `fs` module.
+ */
+
+#include "async_job.h"
+
+#include <errno.h>
+
+static int xt_fs_option_bool(xt_value options, const char *key, int fallback) {
+  if (!XT_IS_OBJECT(options)) return fallback;
+  xt_value value = xt_object_get_cstr(options, key);
+  if (XT_IS_UNDEFINED(value) || XT_IS_NULL(value)) return fallback;
+  return xt_truthy(value);
+}
+
+static int xt_fs_option_recursive(xt_value options) {
+  if (!xt_truthy(options)) return 0;
+  if (XT_IS_OBJECT(options)) return xt_truthy(xt_object_get_cstr(options, "recursive"));
+  return 1;
+}
+
+/* -- file contents --------------------------------------------------------- */
+
+xt_value xt_node_p_read_file(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_READ_FILE);
+  job->path = xt_fs_take_string(argv[0]);
+  job->text = xt_fs_copy_cstr(argc > 1 ? xt_fs_encoding(argv[1]) : NULL);
+  return xt_fs_job_submit(job);
+}
+
+static xt_value xt_fs_write(int32_t argc, xt_value *argv, int append) {
+  if (argc < 2) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_WRITE_FILE);
+  job->path = xt_fs_take_string(argv[0]);
+  job->flags = append;
+  if (xt_node_is_buffer(argv[1])) {
+    job->data = xt_node_buffer_bytes(argv[1], &job->data_length);
+  } else {
+    xt_value text = xt_to_string(argv[1]);
+    const char *data = xt_string_data(text);
+    int32_t length = xt_string_length_value(text);
+    if (data && length >= 0) {
+      const char *encoding = argc > 2 ? xt_fs_encoding(argv[2]) : NULL;
+      job->data = xt_fs_decode_text(data, (size_t)length, encoding, &job->data_length);
+    }
+  }
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_write_file(int32_t argc, xt_value *argv) { return xt_fs_write(argc, argv, 0); }
+
+xt_value xt_node_p_append_file(int32_t argc, xt_value *argv) { return xt_fs_write(argc, argv, 1); }
+
+/* -- directories ----------------------------------------------------------- */
+
+xt_value xt_node_p_mkdir(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_MKDIR);
+  job->path = xt_fs_take_string(argv[0]);
+  job->mode = 0777;
+  xt_value options = argc > 1 ? argv[1] : XT_UNDEFINED;
+  if (XT_IS_OBJECT(options) && !XT_IS_UNDEFINED(xt_object_get_cstr(options, "mode"))) {
+    job->mode = (int)xt_to_number(xt_object_get_cstr(options, "mode"));
+  }
+  job->recursive = argc > 1 && xt_fs_option_recursive(options);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_readdir(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_READDIR);
+  job->path = xt_fs_take_string(argv[0]);
+  xt_value options = argc > 1 ? argv[1] : XT_UNDEFINED;
+  job->with_types = xt_fs_option_bool(options, "withFileTypes", 0);
+  job->recursive = xt_fs_option_bool(options, "recursive", 0);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_rm(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_RM);
+  job->path = xt_fs_take_string(argv[0]);
+  job->recursive = argc > 1 && xt_fs_option_recursive(argv[1]);
+  job->force = xt_fs_option_bool(argc > 1 ? argv[1] : XT_UNDEFINED, "force", 0);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_unlink(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_UNLINK);
+  job->path = xt_fs_take_string(argv[0]);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_rmdir(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_RMDIR);
+  job->path = xt_fs_take_string(argv[0]);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_rename(int32_t argc, xt_value *argv) {
+  if (argc < 2) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_RENAME);
+  job->path = xt_fs_take_string(argv[0]);
+  job->path2 = xt_fs_take_string(argv[1]);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_copy_file(int32_t argc, xt_value *argv) {
+  if (argc < 2) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_COPY_FILE);
+  job->path = xt_fs_take_string(argv[0]);
+  job->path2 = xt_fs_take_string(argv[1]);
+  job->flags = argc > 2 ? (int)xt_to_number(argv[2]) : 0;
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_cp(int32_t argc, xt_value *argv) {
+  if (argc < 2) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_CP);
+  job->path = xt_fs_take_string(argv[0]);
+  job->path2 = xt_fs_take_string(argv[1]);
+  xt_value options = argc > 2 ? argv[2] : XT_UNDEFINED;
+  job->recursive = xt_fs_option_bool(options, "recursive", 0);
+  job->force = xt_fs_option_bool(options, "force", 1);
+  job->error_on_exist = xt_fs_option_bool(options, "errorOnExist", 0);
+  job->dereference = xt_fs_option_bool(options, "dereference", 0);
+  job->preserve = xt_fs_option_bool(options, "preserveTimestamps", 0);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_realpath(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_REALPATH);
+  job->path = xt_fs_take_string(argv[0]);
+  return xt_fs_job_submit(job);
+}
+
+/* -- metadata -------------------------------------------------------------- */
+
+static xt_value xt_fs_stat_job(xt_fs_job_kind kind, int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(kind);
+  job->path = xt_fs_take_string(argv[0]);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_stat(int32_t argc, xt_value *argv) {
+  return xt_fs_stat_job(XT_FS_JOB_STAT, argc, argv);
+}
+
+xt_value xt_node_p_lstat(int32_t argc, xt_value *argv) {
+  return xt_fs_stat_job(XT_FS_JOB_LSTAT, argc, argv);
+}
+
+xt_value xt_node_p_statfs(int32_t argc, xt_value *argv) {
+  return xt_fs_stat_job(XT_FS_JOB_STATFS, argc, argv);
+}
+
+xt_value xt_node_p_access(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_ACCESS);
+  job->path = xt_fs_take_string(argv[0]);
+  job->mode = argc > 1 ? (int)xt_to_number(argv[1]) : F_OK;
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_open(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_OPEN);
+  job->path = xt_fs_take_string(argv[0]);
+  job->flags = argc > 1 ? xt_fs_parse_flags(argv[1]) : (XT_FS_RDONLY | XT_FS_BINARY_FLAG);
+  job->mode = argc > 2 ? (int)xt_to_number(argv[2]) : 0666;
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_chmod(int32_t argc, xt_value *argv) {
+  if (argc < 2) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_CHMOD);
+  job->path = xt_fs_take_string(argv[0]);
+  job->mode = (int)xt_to_number(argv[1]);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_lchmod(int32_t argc, xt_value *argv) {
+  if (argc < 2) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_LCHMOD);
+  job->path = xt_fs_take_string(argv[0]);
+  job->mode = (int)xt_to_number(argv[1]);
+  return xt_fs_job_submit(job);
+}
+
+static xt_value xt_fs_chown_job(xt_fs_job_kind kind, int32_t argc, xt_value *argv) {
+  if (argc < 3) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(kind);
+  job->path = xt_fs_take_string(argv[0]);
+  job->uid = (int)xt_to_number(argv[1]);
+  job->gid = (int)xt_to_number(argv[2]);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_chown(int32_t argc, xt_value *argv) {
+  return xt_fs_chown_job(XT_FS_JOB_CHOWN, argc, argv);
+}
+
+xt_value xt_node_p_lchown(int32_t argc, xt_value *argv) {
+  return xt_fs_chown_job(XT_FS_JOB_LCHOWN, argc, argv);
+}
+
+xt_value xt_node_p_truncate(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_TRUNCATE);
+  job->path = xt_fs_take_string(argv[0]);
+  job->length = argc > 1 ? (long long)xt_to_number(argv[1]) : 0;
+  return xt_fs_job_submit(job);
+}
+
+static xt_value xt_fs_utimes_job(xt_fs_job_kind kind, int32_t argc, xt_value *argv) {
+  if (argc < 3) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(kind);
+  job->path = xt_fs_take_string(argv[0]);
+  job->atime = xt_fs_time_seconds(argv[1]);
+  job->mtime = xt_fs_time_seconds(argv[2]);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_utimes(int32_t argc, xt_value *argv) {
+  return xt_fs_utimes_job(XT_FS_JOB_UTIMES, argc, argv);
+}
+
+xt_value xt_node_p_lutimes(int32_t argc, xt_value *argv) {
+  return xt_fs_utimes_job(XT_FS_JOB_LUTIMES, argc, argv);
+}
+
+/* -- links and temporary directories --------------------------------------- */
+
+xt_value xt_node_p_link(int32_t argc, xt_value *argv) {
+  if (argc < 2) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_LINK);
+  job->path = xt_fs_take_string(argv[0]);
+  job->path2 = xt_fs_take_string(argv[1]);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_symlink(int32_t argc, xt_value *argv) {
+  if (argc < 2) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_SYMLINK);
+  job->path = xt_fs_take_string(argv[0]);
+  job->path2 = xt_fs_take_string(argv[1]);
+  job->text = argc > 2 ? xt_fs_take_string(argv[2]) : NULL;
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_readlink(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_READLINK);
+  job->path = xt_fs_take_string(argv[0]);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_mkdtemp(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_MKDTEMP);
+  job->path = xt_fs_take_string(argv[0]);
+  return xt_fs_job_submit(job);
+}
+
+/* -- opendir / glob / watch ------------------------------------------------ */
+
+xt_value xt_node_p_opendir(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_OPENDIR);
+  job->path = xt_fs_take_string(argv[0]);
+  return xt_fs_job_submit(job);
+}
+
+xt_value xt_node_p_glob(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_promise_resolve(XT_UNDEFINED);
+  xt_fs_job *job = xt_fs_job_new(XT_FS_JOB_GLOB);
+  xt_value pattern = argv[0];
+  if (XT_IS_ARRAY(pattern)) {
+    int32_t count = (int32_t)xt_to_number(xt_array_length(pattern));
+    if (count > 0) {
+      job->patterns = (char **)calloc((size_t)count, sizeof(char *));
+      if (!job->patterns) abort();
+      for (int32_t i = 0; i < count; i++) {
+        xt_value item = xt_array_get(pattern, xt_number((double)i));
+        if (XT_IS_STRING(item)) {
+          job->patterns[job->pattern_count++] = xt_fs_take_string(item);
+        }
+      }
+    }
+  } else {
+    job->text = xt_fs_take_string(pattern);
+  }
+  xt_value options = argc > 1 ? argv[1] : XT_UNDEFINED;
+  job->with_types = xt_fs_option_bool(options, "withFileTypes", 0);
+  xt_value cwd = XT_IS_OBJECT(options) ? xt_object_get_cstr(options, "cwd") : XT_UNDEFINED;
+  if (XT_IS_STRING(cwd)) job->path2 = xt_fs_take_string(cwd);
+  return xt_fs_job_submit(job);
+}
+
+/* There is no real file-watching backend yet; keep the synchronous inert
+ * watcher behind an already-settled promise. */
+xt_value xt_node_p_watch(int32_t argc, xt_value *argv) {
+  return xt_fs_promisify(xt_node_watch, argc, argv);
+}