xbintsc 0.3.79 → 0.3.87

package/runtime/ext_gui/style_values.cpp

@@ -441,6 +441,49 @@ void xt_style_apply_declaration(XtStyle *style, const std::string &property,
     return;
   }
 
+  if (property == "transform") {
+    std::vector<TransformOp> ops;
+    if (xt_transform_parse(value, &ops)) style->transform = ops;
+    return;
+  }
+  if (property == "transform-origin") {
+    /* One or two values plus an optional z offset (ignored: the engine is 2D).
+     * The keywords carry an axis, so `top` alone means `center top` and
+     * `top center` is the same as `center top`. */
+    std::vector<std::string> parts = xt_css_split_whitespace(value);
+    Length values[2] = {Length{50.0f, Unit::Percent}, Length{50.0f, Unit::Percent}};
+    bool vertical[2] = {false, false};
+    size_t used = 0;
+    for (const std::string &part : parts) {
+      if (used >= 2) break;
+      std::string keyword = xt_css_lower(part);
+      Length length = xt_css_parse_length(keyword);
+      if (length.unit == Unit::Invalid || length.unit == Unit::Auto || length.unit == Unit::None) {
+        if (keyword == "left" || keyword == "top") length = {0.0f, Unit::Percent};
+        else if (keyword == "center") length = {50.0f, Unit::Percent};
+        else if (keyword == "right" || keyword == "bottom") length = {100.0f, Unit::Percent};
+        else return;
+        vertical[used] = keyword == "top" || keyword == "bottom";
+      }
+      values[used++] = length;
+    }
+    if (used == 0) return;
+    Length x = values[0];
+    Length y = used > 1 ? values[1] : Length{50.0f, Unit::Percent};
+    if (used > 1) {
+      if (vertical[0] && !vertical[1]) {
+        x = values[1];
+        y = values[0];
+      }
+    } else if (vertical[0]) {
+      /* `top`/`bottom` on their own keep x centred. */
+      x = Length{50.0f, Unit::Percent};
+      y = values[0];
+    }
+    style->transform_origin_x = x;
+    style->transform_origin_y = y;
+    return;
+  }
   if (property == "opacity") {
     float number = 0;
     if (xt_css_parse_number(value, &number)) style->opacity = number < 0 ? 0 : (number > 1 ? 1 : number);

package/runtime/ext_gui/transform.cpp

@@ -0,0 +1,412 @@
+/*
+ * xbintsc GUI engine — CSS `transform`/`transform-origin` parsing, composition
+ * and interpolation.
+ *
+ * `style.cpp`/`style_values.cpp` call `xt_transform_parse` to turn a declaration
+ * value into a list of `TransformOp`s; `layout.cpp` asks `xt_transform_matrix`
+ * for the composition once it knows the box size; `document.cpp` asks
+ * `xt_transform_interpolate` while a transition runs; `style_print.cpp` asks
+ * `xt_transform_to_string` for `getComputedStyle`.
+ */
+
+#include "transform.h"
+
+#include <cctype>
+#include <cmath>
+#include <cstdlib>
+
+#include "css_internal.h"
+#include "style_internal.h"
+
+namespace xtgui {
+
+namespace {
+
+constexpr float kPi = 3.14159265358979323846f;
+/** `rem` units inside a transform resolve against the initial font size; the
+ * computed style carries `font-size` in pixels, so the root size is not
+ * available here (layout only has the element's own style). */
+constexpr float kRootFontSize = 16.0f;
+
+bool isSpace(char c) { return xt_is_css_space(c); }
+
+std::string trim(const std::string &text) { return xt_css_trim(text); }
+
+/** Split `a, b` / `a b` / `a,b` into its arguments. */
+std::vector<std::string> splitArgs(const std::string &text) {
+  std::vector<std::string> parts;
+  size_t index = 0;
+  while (index < text.size()) {
+    while (index < text.size() && (isSpace(text[index]) || text[index] == ',')) index++;
+    size_t start = index;
+    while (index < text.size() && !isSpace(text[index]) && text[index] != ',') index++;
+    if (index > start) parts.push_back(text.substr(start, index - start));
+  }
+  return parts;
+}
+
+bool parseLengthArg(const std::string &token, Length *out) {
+  Length length = xt_css_parse_length(token);
+  if (length.unit == Unit::Invalid || length.unit == Unit::Auto || length.unit == Unit::None) {
+    return false;
+  }
+  *out = length;
+  return true;
+}
+
+/** A unitless number, optionally a percentage (which is divided by 100). */
+bool parseFactorArg(const std::string &raw, float *out) {
+  std::string token = trim(raw);
+  if (token.empty()) return false;
+  bool percent = token.back() == '%';
+  if (percent) token.pop_back();
+  float number = 0;
+  if (!xt_css_parse_number(token, &number)) return false;
+  *out = percent ? number / 100.0f : number;
+  return true;
+}
+
+bool parseAngleArg(const std::string &raw, float *out) {
+  std::string token = xt_css_lower(trim(raw));
+  if (token.empty()) return false;
+  char *end = nullptr;
+  double number = std::strtod(token.c_str(), &end);
+  if (end == token.c_str()) return false;
+  std::string unit = trim(std::string(end));
+  float radians = 0;
+  if (unit.empty() || unit == "deg") radians = (float)number * kPi / 180.0f;
+  else if (unit == "rad") radians = (float)number;
+  else if (unit == "grad") radians = (float)number * kPi / 200.0f;
+  else if (unit == "turn") radians = (float)number * 2.0f * kPi;
+  else return false;
+  *out = radians;
+  return true;
+}
+
+/** Translate one parsed function call into a `TransformOp`. */
+bool applyFunction(const std::string &name, const std::vector<std::string> &args,
+                   TransformOp *op) {
+  if (name == "translate" || name == "translate3d") {
+    /* The 3d spelling takes a `z` we parse and drop: the engine is 2D. */
+    size_t most = name == "translate3d" ? 3 : 2;
+    if (args.empty() || args.size() > most) return false;
+    op->kind = TransformKind::Translate;
+    if (!parseLengthArg(args[0], &op->x)) return false;
+    op->y = Length{0.0f, Unit::Px};
+    if (args.size() >= 2 && !parseLengthArg(args[1], &op->y)) return false;
+    return true;
+  }
+  if (name == "translatex") {
+    if (args.size() != 1) return false;
+    op->kind = TransformKind::TranslateX;
+    op->y = Length{0.0f, Unit::Px};
+    return parseLengthArg(args[0], &op->x);
+  }
+  if (name == "translatey") {
+    if (args.size() != 1) return false;
+    op->kind = TransformKind::TranslateY;
+    op->x = Length{0.0f, Unit::Px};
+    return parseLengthArg(args[0], &op->y);
+  }
+  if (name == "scale" || name == "scale3d") {
+    size_t most = name == "scale3d" ? 3 : 2;
+    if (args.empty() || args.size() > most) return false;
+    op->kind = TransformKind::Scale;
+    if (!parseFactorArg(args[0], &op->scale_x)) return false;
+    op->scale_y = op->scale_x;
+    if (args.size() >= 2 && !parseFactorArg(args[1], &op->scale_y)) return false;
+    return true;
+  }
+  if (name == "scalex") {
+    if (args.size() != 1) return false;
+    op->kind = TransformKind::ScaleX;
+    op->scale_y = 1.0f;
+    return parseFactorArg(args[0], &op->scale_x);
+  }
+  if (name == "scaley") {
+    if (args.size() != 1) return false;
+    op->kind = TransformKind::ScaleY;
+    op->scale_x = 1.0f;
+    return parseFactorArg(args[0], &op->scale_y);
+  }
+  if (name == "rotate" || name == "rotatez") {
+    if (args.size() != 1) return false;
+    op->kind = TransformKind::Rotate;
+    return parseAngleArg(args[0], &op->angle);
+  }
+  if (name == "matrix") {
+    if (args.size() != 6) return false;
+    op->kind = TransformKind::Matrix;
+    for (size_t i = 0; i < 6; i++) {
+      if (!xt_css_parse_number(args[i], &op->matrix[i])) return false;
+    }
+    return true;
+  }
+  return false;  // skew/perspective/… are not supported yet
+}
+
+float resolveLength(const Length &length, float base, float em, float vw, float vh) {
+  return xt_style_resolve_absolute(length, base, em, kRootFontSize, vw, vh);
+}
+
+bool sameLength(const Length &left, const Length &right) {
+  return left.unit == right.unit && left.value == right.value;
+}
+
+bool sameOp(const TransformOp &left, const TransformOp &right) {
+  if (left.kind != right.kind) return false;
+  switch (left.kind) {
+    case TransformKind::Translate:
+      return sameLength(left.x, right.x) && sameLength(left.y, right.y);
+    case TransformKind::TranslateX:
+      return sameLength(left.x, right.x);
+    case TransformKind::TranslateY:
+      return sameLength(left.y, right.y);
+    case TransformKind::Scale:
+      return left.scale_x == right.scale_x && left.scale_y == right.scale_y;
+    case TransformKind::ScaleX:
+      return left.scale_x == right.scale_x;
+    case TransformKind::ScaleY:
+      return left.scale_y == right.scale_y;
+    case TransformKind::Rotate:
+      return left.angle == right.angle;
+    case TransformKind::Matrix:
+      for (int i = 0; i < 6; i++) {
+        if (left.matrix[i] != right.matrix[i]) return false;
+      }
+      return true;
+  }
+  return false;
+}
+
+bool mixLength(const Length &from, const Length &to, float t, Length *out) {
+  if (from.unit != to.unit) return false;
+  out->unit = from.unit;
+  out->value = from.value + (to.value - from.value) * t;
+  return true;
+}
+
+}  // namespace
+
+Matrix2D Matrix2D::rotate(float radians) {
+  Matrix2D out;
+  float cosine = std::cos(radians);
+  float sine = std::sin(radians);
+  out.a = cosine;
+  out.b = sine;
+  out.c = -sine;
+  out.d = cosine;
+  return out;
+}
+
+Matrix2D Matrix2D::multiply(const Matrix2D &other) const {
+  Matrix2D out;
+  out.a = a * other.a + c * other.b;
+  out.b = b * other.a + d * other.b;
+  out.c = a * other.c + c * other.d;
+  out.d = b * other.c + d * other.d;
+  out.e = a * other.e + c * other.f + e;
+  out.f = b * other.e + d * other.f + f;
+  return out;
+}
+
+bool Matrix2D::invert(Matrix2D *out) const {
+  float determinant = a * d - b * c;
+  if (std::fabs(determinant) < 1e-9f) return false;
+  float inverse = 1.0f / determinant;
+  Matrix2D result;
+  result.a = d * inverse;
+  result.b = -b * inverse;
+  result.c = -c * inverse;
+  result.d = a * inverse;
+  result.e = -(result.a * e + result.c * f);
+  result.f = -(result.b * e + result.d * f);
+  *out = result;
+  return true;
+}
+
+float Matrix2D::magnification() const {
+  float determinant = std::fabs(a * d - b * c);
+  return std::sqrt(determinant);
+}
+
+bool xt_transform_parse(const std::string &value, std::vector<TransformOp> *out) {
+  out->clear();
+  std::string text = trim(value);
+  std::string lowered = xt_css_lower(text);
+  if (lowered.empty() || lowered == "none") return true;
+
+  size_t pos = 0;
+  while (pos < text.size()) {
+    while (pos < text.size() && isSpace(text[pos])) pos++;
+    if (pos >= text.size()) break;
+    size_t name_start = pos;
+    /* A function name may carry digits: `translate3d`, `scale3d`, `matrix3d`. */
+    while (pos < text.size() && (std::isalnum((unsigned char)text[pos]) || text[pos] == '-')) pos++;
+    if (pos == name_start) return false;
+    std::string name = xt_css_lower(text.substr(name_start, pos - name_start));
+    while (pos < text.size() && isSpace(text[pos])) pos++;
+    if (pos >= text.size() || text[pos] != '(') return false;
+    pos++;
+    size_t args_start = pos;
+    int depth = 1;
+    while (pos < text.size() && depth > 0) {
+      if (text[pos] == '(') depth++;
+      else if (text[pos] == ')') depth--;
+      pos++;
+    }
+    if (depth != 0) return false;
+    std::string inner = text.substr(args_start, pos - 1 - args_start);
+    TransformOp op;
+    if (!applyFunction(name, splitArgs(inner), &op)) return false;
+    out->push_back(op);
+  }
+  return true;
+}
+
+bool xt_transform_equal(const std::vector<TransformOp> &left,
+                        const std::vector<TransformOp> &right) {
+  if (left.size() != right.size()) return false;
+  for (size_t i = 0; i < left.size(); i++) {
+    if (!sameOp(left[i], right[i])) return false;
+  }
+  return true;
+}
+
+bool xt_transform_interpolate(const std::vector<TransformOp> &from,
+                              const std::vector<TransformOp> &to, float t,
+                              std::vector<TransformOp> *out) {
+  if (from.size() != to.size()) return false;
+  std::vector<TransformOp> mixed(from.size());
+  for (size_t i = 0; i < from.size(); i++) {
+    const TransformOp &left = from[i];
+    const TransformOp &right = to[i];
+    if (left.kind != right.kind) return false;
+    TransformOp op;
+    op.kind = left.kind;
+    switch (left.kind) {
+      case TransformKind::Translate:
+        if (!mixLength(left.x, right.x, t, &op.x)) return false;
+        if (!mixLength(left.y, right.y, t, &op.y)) return false;
+        break;
+      case TransformKind::TranslateX:
+        if (!mixLength(left.x, right.x, t, &op.x)) return false;
+        break;
+      case TransformKind::TranslateY:
+        if (!mixLength(left.y, right.y, t, &op.y)) return false;
+        break;
+      case TransformKind::Scale:
+        op.scale_x = left.scale_x + (right.scale_x - left.scale_x) * t;
+        op.scale_y = left.scale_y + (right.scale_y - left.scale_y) * t;
+        break;
+      case TransformKind::ScaleX:
+        op.scale_x = left.scale_x + (right.scale_x - left.scale_x) * t;
+        break;
+      case TransformKind::ScaleY:
+        op.scale_y = left.scale_y + (right.scale_y - left.scale_y) * t;
+        break;
+      case TransformKind::Rotate:
+        op.angle = left.angle + (right.angle - left.angle) * t;
+        break;
+      case TransformKind::Matrix:
+        for (int entry = 0; entry < 6; entry++) {
+          op.matrix[entry] = left.matrix[entry] + (right.matrix[entry] - left.matrix[entry]) * t;
+        }
+        break;
+    }
+    mixed[i] = op;
+  }
+  *out = mixed;
+  return true;
+}
+
+Matrix2D xt_transform_matrix(const std::vector<TransformOp> &ops, float percent_width,
+                             float percent_height, float em, float viewport_width,
+                             float viewport_height) {
+  Matrix2D result;
+  for (const TransformOp &op : ops) {
+    Matrix2D step;
+    switch (op.kind) {
+      case TransformKind::Translate:
+        step.e = resolveLength(op.x, percent_width, em, viewport_width, viewport_height);
+        step.f = resolveLength(op.y, percent_height, em, viewport_width, viewport_height);
+        break;
+      case TransformKind::TranslateX:
+        step.e = resolveLength(op.x, percent_width, em, viewport_width, viewport_height);
+        break;
+      case TransformKind::TranslateY:
+        step.f = resolveLength(op.y, percent_height, em, viewport_width, viewport_height);
+        break;
+      case TransformKind::Scale:
+        step = Matrix2D::scale(op.scale_x, op.scale_y);
+        break;
+      case TransformKind::ScaleX:
+        step = Matrix2D::scale(op.scale_x, 1.0f);
+        break;
+      case TransformKind::ScaleY:
+        step = Matrix2D::scale(1.0f, op.scale_y);
+        break;
+      case TransformKind::Rotate:
+        step = Matrix2D::rotate(op.angle);
+        break;
+      case TransformKind::Matrix:
+        step.a = op.matrix[0];
+        step.b = op.matrix[1];
+        step.c = op.matrix[2];
+        step.d = op.matrix[3];
+        step.e = op.matrix[4];
+        step.f = op.matrix[5];
+        break;
+    }
+    result = result.multiply(step);
+  }
+  return result;
+}
+
+std::string xt_transform_to_string(const std::vector<TransformOp> &ops) {
+  if (ops.empty()) return "none";
+  std::string text;
+  for (size_t i = 0; i < ops.size(); i++) {
+    if (i > 0) text += " ";
+    const TransformOp &op = ops[i];
+    switch (op.kind) {
+      case TransformKind::Translate:
+        text += "translate(" + xt_style_length_to_string(op.x) + ", " +
+                xt_style_length_to_string(op.y) + ")";
+        break;
+      case TransformKind::TranslateX:
+        text += "translateX(" + xt_style_length_to_string(op.x) + ")";
+        break;
+      case TransformKind::TranslateY:
+        text += "translateY(" + xt_style_length_to_string(op.y) + ")";
+        break;
+      case TransformKind::Scale:
+        text += "scale(" + xt_style_length_to_string(Length{op.scale_x, Unit::Number}) + ", " +
+                xt_style_length_to_string(Length{op.scale_y, Unit::Number}) + ")";
+        break;
+      case TransformKind::ScaleX:
+        text += "scaleX(" + xt_style_length_to_string(Length{op.scale_x, Unit::Number}) + ")";
+        break;
+      case TransformKind::ScaleY:
+        text += "scaleY(" + xt_style_length_to_string(Length{op.scale_y, Unit::Number}) + ")";
+        break;
+      case TransformKind::Rotate: {
+        char buffer[64];
+        std::snprintf(buffer, sizeof(buffer), "rotate(%.4gdeg)", (double)(op.angle * 180.0f / kPi));
+        text += buffer;
+        break;
+      }
+      case TransformKind::Matrix: {
+        char buffer[160];
+        std::snprintf(buffer, sizeof(buffer), "matrix(%.6g, %.6g, %.6g, %.6g, %.6g, %.6g)",
+                      (double)op.matrix[0], (double)op.matrix[1], (double)op.matrix[2],
+                      (double)op.matrix[3], (double)op.matrix[4], (double)op.matrix[5]);
+        text += buffer;
+        break;
+      }
+    }
+  }
+  return text;
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/transform.h

@@ -0,0 +1,112 @@
+/*
+ * xbintsc GUI engine — CSS `transform` and `transform-origin`.
+ *
+ * A `transform` declaration is parsed into a list of `TransformOp`s (the
+ * familiar `translate(...) rotate(...) scale(...)` chain, plus `matrix(...)`).
+ * Lengths stay unresolved in the list, because percentages and `em`/`vw`
+ * units need the box that carries them — which only layout knows. Layout
+ * therefore resolves the list into a `Matrix2D`, and paint, hit testing and
+ * `getBoundingClientRect` all consume that one matrix.
+ *
+ * Transforms are a *paint-time* effect: they never change layout geometry, so
+ * a transform cannot move a sibling, and it must be composed down the subtree
+ * (a child of a transformed box is transformed too).
+ */
+#ifndef XT_GUI_TRANSFORM_H
+#define XT_GUI_TRANSFORM_H
+
+#include <string>
+#include <vector>
+
+#include "css.h"
+
+namespace xtgui {
+
+/** A 2D affine transform laid out like the DOM `DOMMatrix` (a b c d e f):
+ * `x' = a*x + c*y + e`, `y' = b*x + d*y + f`. */
+struct Matrix2D {
+  float a = 1.0f, b = 0.0f, c = 0.0f, d = 1.0f, e = 0.0f, f = 0.0f;
+
+  bool identity() const {
+    return a == 1.0f && b == 0.0f && c == 0.0f && d == 1.0f && e == 0.0f && f == 0.0f;
+  }
+  /** True when the transform keeps axis-aligned rectangles axis aligned (no
+   * rotation or skew). */
+  bool axis_aligned() const { return b == 0.0f && c == 0.0f; }
+  void apply(float x, float y, float *out_x, float *out_y) const {
+    *out_x = a * x + c * y + e;
+    *out_y = b * x + d * y + f;
+  }
+  /** `this * other`: the point is put through `other` first, then `this`. */
+  Matrix2D multiply(const Matrix2D &other) const;
+  /** The inverse transform, or false for a singular matrix (scale 0). */
+  bool invert(Matrix2D *out) const;
+  /** Approximate uniform magnification (geometric mean of the axis scales). */
+  float magnification() const;
+
+  static Matrix2D translate(float x, float y) {
+    Matrix2D out;
+    out.e = x;
+    out.f = y;
+    return out;
+  }
+  static Matrix2D scale(float x, float y) {
+    Matrix2D out;
+    out.a = x;
+    out.d = y;
+    return out;
+  }
+  static Matrix2D rotate(float radians);
+};
+
+enum class TransformKind {
+  Translate,
+  TranslateX,
+  TranslateY,
+  Scale,
+  ScaleX,
+  ScaleY,
+  Rotate,
+  Matrix,
+};
+
+/** One function in a parsed `transform` list. Only the fields its `kind` uses
+ * carry a value; the rest stay at their neutral defaults. */
+struct TransformOp {
+  TransformKind kind = TransformKind::Translate;
+  Length x;                    // translate x; `%` resolves against the box width
+  Length y;                    // translate y; `%` resolves against the box height
+  float scale_x = 1.0f;        // scale x (a unitless factor)
+  float scale_y = 1.0f;        // scale y
+  float angle = 0.0f;          // rotate, in radians
+  float matrix[6] = {1, 0, 0, 1, 0, 0};  // a b c d e f
+};
+
+/** Parse a `transform` value. `none` (or an empty list) yields an empty vector.
+ * An unsupported function or a malformed argument returns false, which makes
+ * the whole declaration invalid — exactly what CSS does. */
+bool xt_transform_parse(const std::string &value, std::vector<TransformOp> *out);
+
+/** Structural equality (used to decide whether a transition is needed). */
+bool xt_transform_equal(const std::vector<TransformOp> &left,
+                        const std::vector<TransformOp> &right);
+
+/** Interpolate two lists of the same shape (same kinds, compatible units) at
+ * progress `t` in [0, 1]. Returns false when the lists cannot be mixed, in
+ * which case the caller should snap to the target. */
+bool xt_transform_interpolate(const std::vector<TransformOp> &from,
+                              const std::vector<TransformOp> &to, float t,
+                              std::vector<TransformOp> *out);
+
+/** Compose a `transform` list into one matrix. `percent_width`/`percent_height`
+ * are the element's border-box size (the base for `%`), `em` its font size. */
+Matrix2D xt_transform_matrix(const std::vector<TransformOp> &ops, float percent_width,
+                             float percent_height, float em, float viewport_width,
+                             float viewport_height);
+
+/** Canonical function-list spelling, for `getComputedStyle(el, "transform")`. */
+std::string xt_transform_to_string(const std::vector<TransformOp> &ops);
+
+}  // namespace xtgui
+
+#endif /* XT_GUI_TRANSFORM_H */

package/runtime/ext_gui/window.cpp

@@ -147,11 +147,13 @@ static xt_value win_get_bounding_rect(xt_value self, xt_value env, int32_t argc,
   if (node == nullptr) return XT_UNDEFINED;
   const xtgui::LayoutBox *box = win->document->boxOf(node);
   if (box == nullptr) return XT_UNDEFINED;
+  /* Like the DOM: the rectangle of the *transformed* border box. */
+  xtgui::LayoutRect rect = xtgui::xt_layout_transformed_bounds(box);
   xt_value object = xt_object_new();
-  xt_object_set(object, xt_string_from_cstr("x"), xt_number(box->x));
-  xt_object_set(object, xt_string_from_cstr("y"), xt_number(box->y));
-  xt_object_set(object, xt_string_from_cstr("width"), xt_number(box->width));
-  xt_object_set(object, xt_string_from_cstr("height"), xt_number(box->height));
+  xt_object_set(object, xt_string_from_cstr("x"), xt_number(rect.x));
+  xt_object_set(object, xt_string_from_cstr("y"), xt_number(rect.y));
+  xt_object_set(object, xt_string_from_cstr("width"), xt_number(rect.width));
+  xt_object_set(object, xt_string_from_cstr("height"), xt_number(rect.height));
   return object;
 }
 

package/runtime/ext_node/buffer/parts/construction.inc

@@ -25,7 +25,7 @@ static xt_value xt_buffer_from(xt_value value, const char *encoding) {
   xt_value text = xt_to_string(value);
   xt_string *string = xt_as_string(text);
   size_t decoded = 0;
-  unsigned char *bytes = xt_node_decode(string->data, string->length, encoding, &decoded);
+  unsigned char *bytes = xt_node_decode(xt_string_bytes(string), string->length, encoding, &decoded);
   if (!bytes) return xt_buffer_new(0, NULL);
   xt_value result = xt_buffer_from_bytes(bytes, decoded);
   free(bytes);
@@ -49,7 +49,7 @@ static xt_value xt_buffer_alloc(uint32_t size, xt_value fill, const char *encodi
   xt_value text = xt_to_string(fill);
   xt_string *string = xt_as_string(text);
   size_t decoded = 0;
-  unsigned char *bytes = xt_node_decode(string->data, string->length, encoding, &decoded);
+  unsigned char *bytes = xt_node_decode(xt_string_bytes(string), string->length, encoding, &decoded);
   if (!bytes || decoded == 0) {
     free(bytes);
     return buffer;

package/runtime/ext_node/buffer/parts/methods.inc

@@ -93,7 +93,7 @@ static xt_value xt_buffer_method_write(xt_value thisValue, xt_value env, int32_t
   uint32_t offset = argc > 1 ? (uint32_t)xt_to_number(argv[1]) : 0;
   const char *encoding = argc > 3 ? xt_node_encoding(argv[3]) : NULL;
   size_t decoded = 0;
-  unsigned char *bytes = xt_node_decode(string->data, string->length, encoding, &decoded);
+  unsigned char *bytes = xt_node_decode(xt_string_bytes(string), string->length, encoding, &decoded);
   uint32_t available = xt_buffer_length(thisValue);
   uint32_t written = 0;
   for (size_t i = 0; i < decoded && offset + written < available; i++) {

package/runtime/ext_node/buffer/parts/search.inc

@@ -19,7 +19,7 @@ static const unsigned char *xt_buffer_search_needle(xt_value value, const char *
   xt_value text = xt_to_string(value);
   xt_string *string = xt_as_string(text);
   size_t decoded = 0;
-  unsigned char *bytes = xt_node_decode(string->data, string->length, encoding, &decoded);
+  unsigned char *bytes = xt_node_decode(xt_string_bytes(string), string->length, encoding, &decoded);
   *length = decoded;
   return bytes;
 }

package/runtime/ext_node/child_process/child_process.c

@@ -82,6 +82,27 @@ static char *read_temp(FILE *file) {
   return buffer;
 }
 
+/*
+ * MSVC's `_spawnvp` builds the child command line from argv without quoting
+ * argv[0]. When the executable path contains a space — the default install
+ * location is "C:\Program Files\…" — the child sees the path split into several
+ * arguments ("Files\Microsoft", "Visual", …). Quote argv[0] ourselves. Returns
+ * NULL when no quoting is needed (the caller keeps the original pointer).
+ */
+static char *quote_argv0(char **child_argv) {
+  const char *arg = child_argv[0];
+  if (arg == NULL || strchr(arg, ' ') == NULL) return NULL;
+  size_t length = strlen(arg);
+  char *quoted = (char *)malloc(length + 3);
+  if (!quoted) return NULL;
+  quoted[0] = '"';
+  memcpy(quoted + 1, arg, length);
+  quoted[length + 1] = '"';
+  quoted[length + 2] = 0;
+  child_argv[0] = quoted;
+  return quoted;
+}
+
 xt_value xt_child_process_spawn_sync(int32_t argc, xt_value *argv) {
   const char *command = argc > 0 ? xt_string_data(xt_to_string(argv[0])) : NULL;
   if (!command) command = "";
@@ -91,6 +112,7 @@ xt_value xt_child_process_spawn_sync(int32_t argc, xt_value *argv) {
   int count = 0;
   char **child_argv = (char **)build_argv(command, args, &count);
   if (!child_argv) return make_result(-1, "", "out of memory");
+  char *quoted_command = quote_argv0(child_argv);
 
   char previous[4096];
   int had_cwd = cwd && _getcwd(previous, sizeof(previous)) != NULL;
@@ -99,6 +121,7 @@ xt_value xt_child_process_spawn_sync(int32_t argc, xt_value *argv) {
     if (cwd) _chdir(cwd);
     intptr_t inherit_rc = _spawnvp(_P_WAIT, command, (const char *const *)child_argv);
     if (had_cwd) _chdir(previous);
+    free(quoted_command);
     free(child_argv);
     return make_result(inherit_rc < 0 ? -1 : (double)inherit_rc, "", "");
   }
@@ -106,6 +129,7 @@ xt_value xt_child_process_spawn_sync(int32_t argc, xt_value *argv) {
   FILE *out_file = tmpfile();
   FILE *err_file = tmpfile();
   if (!out_file || !err_file) {
+    free(quoted_command);
     free(child_argv);
     if (out_file) fclose(out_file);
     if (err_file) fclose(err_file);
@@ -136,6 +160,7 @@ xt_value xt_child_process_spawn_sync(int32_t argc, xt_value *argv) {
   char *err = read_temp(err_file);
   fclose(out_file);
   fclose(err_file);
+  free(quoted_command);
   free(child_argv);
 
   xt_value result = make_result(rc < 0 ? -1 : (double)rc, out, err);