atoo-studio 0.0.1 → 0.0.2

package/setup-cuse.sh

@@ -0,0 +1,260 @@
+#!/bin/bash
+set -e
+
+# Setup CUSE (Character device in Userspace) for virtual serial port support.
+# This enables DTR/RTS control signal forwarding for tools like esptool.py.
+#
+# Must be run as root. Only needed once per system.
+#
+# Requirements:
+#   - Linux VM or bare-metal (NOT a container — see below)
+#   - Root access
+#   - gcc, pkg-config
+#
+# Container note (LXC/Docker):
+#   CUSE requires kernel module loading and /dev device creation, which
+#   containers cannot do. If running inside a container:
+#     1. On the HOST: modprobe cuse && chmod 0666 /dev/cuse
+#     2. Pass /dev/cuse into the container:
+#        - LXC:    lxc.mount.entry: /dev/cuse dev/cuse none bind,create=file 0 0
+#        - Docker: docker run --device /dev/cuse ...
+#     3. LXC must be PRIVILEGED (unprivileged containers cannot create device nodes)
+#     4. Then run this script inside the container (skip modprobe step)
+#
+#   If you're on an unprivileged LXC container, CUSE won't work.
+#   Use a VM instead, or rely on the PTY fallback (BOOT button for flashing).
+
+if [ "$(id -u)" -ne 0 ]; then
+  echo "Error: This script must be run as root (sudo $0)"
+  exit 1
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+NATIVE_DIR="$SCRIPT_DIR/src/serial/native"
+BUILD_DIR="$NATIVE_DIR/build/Release"
+# Install to ~/.atoo-studio/bin/ so node-gyp rebuilds don't wipe capabilities/suid
+INSTALL_USER="${SUDO_USER:-$(logname 2>/dev/null || echo root)}"
+INSTALL_HOME="$(eval echo "~$INSTALL_USER")"
+INSTALL_DIR="$INSTALL_HOME/.atoo-studio/bin"
+
+echo "=== Setting up CUSE for atoo-studio ==="
+
+# Detect container environment
+VIRT=""
+if command -v systemd-detect-virt &>/dev/null; then
+  VIRT="$(systemd-detect-virt -c 2>/dev/null || true)"
+elif [ -f /proc/1/cgroup ]; then
+  if grep -qE 'lxc|docker|containerd' /proc/1/environ 2>/dev/null || \
+     grep -qE '/lxc/|/docker/' /proc/1/cgroup 2>/dev/null; then
+    VIRT="container"
+  fi
+fi
+# Also check for /.dockerenv
+if [ -f /.dockerenv ]; then
+  VIRT="docker"
+fi
+
+IS_CONTAINER=false
+case "$VIRT" in
+  lxc|lxc-libvirt|docker|podman|container)
+    IS_CONTAINER=true
+    ;;
+esac
+
+if [ "$IS_CONTAINER" = true ]; then
+  echo ""
+  echo "  Container detected: $VIRT"
+  echo ""
+  echo "  CUSE requires kernel-level access that containers don't have."
+  echo "  You need to set this up on the HOST first:"
+  echo ""
+  echo "    1. On the host, load the cuse kernel module:"
+  echo "       sudo modprobe cuse"
+  echo "       echo cuse | sudo tee /etc/modules-load.d/cuse.conf"
+  echo ""
+  echo "    2. On the host, make /dev/cuse accessible:"
+  echo "       sudo chmod 0666 /dev/cuse"
+  echo "       # To persist across reboots, add a udev rule on the host:"
+  echo "       echo 'KERNEL==\"cuse\", MODE=\"0666\"' | sudo tee /etc/udev/rules.d/99-cuse.rules"
+  echo "       sudo udevadm control --reload-rules"
+  echo ""
+  if [ "$VIRT" = "lxc" ] || [ "$VIRT" = "lxc-libvirt" ]; then
+    echo "    3. Pass /dev/cuse into this LXC container and allow device creation."
+    echo "       Add to the container config (e.g. /etc/pve/lxc/<ID>.conf):"
+    echo ""
+    echo "       lxc.cgroup2.devices.allow: a"
+    echo "       lxc.mount.entry: /dev/cuse dev/cuse none bind,create=file 0 0"
+    echo ""
+    echo "       Important: The LXC container MUST be privileged (unprivileged: 0)."
+    echo "       CUSE creates device nodes in /dev which unprivileged containers"
+    echo "       cannot do. Switching an existing container from unprivileged to"
+    echo "       privileged can break file ownership — it's easier to create a"
+    echo "       new privileged container if needed."
+    echo ""
+    echo "       'devices.allow: a' is also required because CUSE creates device"
+    echo "       nodes (/dev/ttyVS*) with dynamically assigned major/minor numbers."
+    echo "       On a VM or bare-metal, none of this is needed."
+    echo ""
+    echo "    4. Restart the container, then re-run this script."
+  elif [ "$VIRT" = "docker" ] || [ "$VIRT" = "podman" ]; then
+    echo "    3. Run the container with --device /dev/cuse"
+    echo "       docker run --device /dev/cuse ..."
+    echo ""
+    echo "    4. Re-run this script inside the container."
+  else
+    echo "    3. Pass /dev/cuse into this container and re-run this script."
+  fi
+  echo ""
+
+  # Check if /dev/cuse was already passed through
+  if [ -e /dev/cuse ]; then
+    echo "  /dev/cuse is available — host setup appears done. Continuing..."
+    echo ""
+
+    # Verify /dev/cuse is actually accessible
+    if [ ! -w /dev/cuse ]; then
+      echo "  Error: /dev/cuse exists but is not writable."
+      echo "  On the HOST, run: sudo chmod 0666 /dev/cuse"
+      echo "  Or add a udev rule (see instructions above)."
+      exit 1
+    fi
+  else
+    echo "  /dev/cuse is NOT available. Complete the host setup above first."
+    echo ""
+    echo "  Note: Without CUSE, atoo-studio will still work using PTY fallback,"
+    echo "  but DTR/RTS control signals won't be forwarded. You'll need to"
+    echo "  use the BOOT button on your device when flashing."
+    exit 1
+  fi
+fi
+
+# 1. Ensure build tools are available (gcc, pkg-config)
+MISSING_PKGS=()
+command -v gcc &>/dev/null || MISSING_PKGS+=(gcc)
+command -v pkg-config &>/dev/null || MISSING_PKGS+=(pkg-config)
+
+if [ ${#MISSING_PKGS[@]} -gt 0 ]; then
+  echo "Installing missing build tools: ${MISSING_PKGS[*]}..."
+  if command -v apt-get &>/dev/null; then
+    apt-get install -y "${MISSING_PKGS[@]}"
+  elif command -v dnf &>/dev/null; then
+    # pkg-config is pkgconf-pkg-config on Fedora/RHEL
+    DNF_PKGS=("${MISSING_PKGS[@]/pkg-config/pkgconf-pkg-config}")
+    dnf install -y "${DNF_PKGS[@]}"
+  elif command -v pacman &>/dev/null; then
+    PAC_PKGS=("${MISSING_PKGS[@]/pkg-config/pkgconf}")
+    pacman -S --noconfirm "${PAC_PKGS[@]}"
+  else
+    echo "Error: Missing ${MISSING_PKGS[*]}. Install them manually."
+    exit 1
+  fi
+fi
+
+# 2. Install libfuse3-dev if needed
+if ! pkg-config --exists fuse3 2>/dev/null; then
+  echo "Installing libfuse3-dev..."
+  if command -v apt-get &>/dev/null; then
+    apt-get install -y libfuse3-dev || true
+    # Verify it actually installed despite possible unrelated dpkg errors
+    if ! pkg-config --exists fuse3 2>/dev/null; then
+      echo "Error: libfuse3-dev failed to install."
+      exit 1
+    fi
+  elif command -v dnf &>/dev/null; then
+    dnf install -y fuse3-devel
+  elif command -v pacman &>/dev/null; then
+    pacman -S --noconfirm fuse3
+  else
+    echo "Error: Could not install libfuse3-dev. Install it manually."
+    exit 1
+  fi
+fi
+
+# 3. Load cuse kernel module (skip in containers — must be done on host)
+if [ "$IS_CONTAINER" = true ]; then
+  if [ ! -e /dev/cuse ]; then
+    echo "Error: /dev/cuse not available. Load cuse module on the host first."
+    exit 1
+  fi
+  echo "Container mode: skipping modprobe (using host-provided /dev/cuse)"
+else
+  if ! lsmod | grep -q '^cuse '; then
+    echo "Loading cuse kernel module..."
+    if ! modprobe cuse 2>/dev/null; then
+      echo ""
+      echo "Error: Failed to load cuse kernel module."
+      echo ""
+      echo "Possible causes:"
+      echo "  - Module not available in your kernel ($(uname -r))"
+      echo "    Try: apt-get install linux-modules-extra-$(uname -r)"
+      echo "    Or rebuild kernel with CONFIG_CUSE=m"
+      echo "  - Running inside a container (modprobe is restricted)"
+      echo ""
+      echo "Without CUSE, atoo-studio will use PTY fallback (no DTR/RTS signals)."
+      echo "You'll need to use the BOOT button on your device when flashing."
+      exit 1
+    fi
+  fi
+
+  # Persist across reboots
+  if [ -d /etc/modules-load.d ]; then
+    echo "cuse" > /etc/modules-load.d/atoo-studio-cuse.conf
+    echo "Persisted cuse module load to /etc/modules-load.d/atoo-studio-cuse.conf"
+  fi
+fi
+
+# 4. Build the CUSE serial helper
+echo "Building cuse_serial..."
+mkdir -p "$BUILD_DIR"
+gcc -Wall -Wextra -O2 \
+  "$NATIVE_DIR/cuse_serial.c" \
+  -o "$BUILD_DIR/cuse_serial" \
+  $(pkg-config --cflags --libs fuse3) \
+  -lpthread
+
+echo "Built: $BUILD_DIR/cuse_serial"
+
+# 5. Install to ~/.atoo-studio/bin/ so node-gyp rebuilds don't wipe capabilities
+echo "Installing cuse_serial to $INSTALL_DIR/ ..."
+mkdir -p "$INSTALL_DIR"
+cp "$BUILD_DIR/cuse_serial" "$INSTALL_DIR/cuse_serial"
+
+# 6. Set capability so it can create /dev/ entries without full root
+echo "Setting CAP_SYS_ADMIN capability on cuse_serial..."
+if setcap cap_sys_admin+ep "$INSTALL_DIR/cuse_serial" 2>/dev/null; then
+  echo "Capability set. cuse_serial can run without root."
+else
+  echo ""
+  echo "  Warning: setcap failed (common in LXC/Docker containers)."
+  echo "  The cuse_serial binary will need to run as root."
+  echo ""
+  echo "  To allow non-root usage, set the suid bit instead:"
+  echo "    sudo chown root:root $INSTALL_DIR/cuse_serial"
+  echo "    sudo chmod u+s $INSTALL_DIR/cuse_serial"
+  echo ""
+  echo "  Or run atoo-studio itself as root (not recommended)."
+  echo ""
+
+  # In container mode, set suid as fallback since setcap doesn't work
+  if [ "$IS_CONTAINER" = true ]; then
+    echo "  Applying suid fallback for container environment..."
+    chown root:root "$INSTALL_DIR/cuse_serial"
+    chmod u+s "$INSTALL_DIR/cuse_serial"
+    echo "  Done: suid bit set on cuse_serial."
+  fi
+fi
+
+# 7. Add udev rule so the created /dev/ttyVS* devices are world-accessible
+if command -v udevadm &>/dev/null; then
+  UDEV_RULE="/etc/udev/rules.d/99-atoo-studio-serial.rules"
+  echo 'KERNEL=="ttyVS[0-9]*", MODE="0666"' > "$UDEV_RULE"
+  udevadm control --reload-rules 2>/dev/null || true
+  echo "Installed udev rule: $UDEV_RULE"
+else
+  echo "Warning: udevadm not found. /dev/ttyVS* devices may need manual chmod."
+fi
+
+echo ""
+echo "=== CUSE setup complete ==="
+echo "Virtual serial devices (/dev/ttyVS*) will now support DTR/RTS control signals."
+echo "No reboot required."

package/setup.sh

@@ -0,0 +1,81 @@
+#!/bin/bash
+set -e
+
+# Install system dependencies for atoo-studio (headless mode).
+# Must be run as root (sudo ./setup.sh).
+#
+# NOTE: If using Docker preview mode (docker/preview/build.sh), these
+# system deps are not needed — everything runs inside the container.
+# Only ffmpeg is still useful on the host for encoding screen recordings.
+
+echo "=== atoo-studio system setup ==="
+
+if [ "$(uname -s)" = "Darwin" ]; then
+  # --- macOS ---
+  # Puppeteer bundles Chromium and macOS has all required system libs.
+  # Only ffmpeg is needed for screen recording support.
+  echo ""
+  echo "Installing ffmpeg for screen recording support..."
+
+  if command -v brew &>/dev/null; then
+    brew install ffmpeg
+  else
+    echo "Error: Homebrew not found. Install it from https://brew.sh"
+    echo "Then re-run this script, or install ffmpeg manually."
+    exit 1
+  fi
+
+  echo ""
+  echo "=== Setup complete ==="
+  echo "You can now run: npx atoo-studio"
+  exit 0
+fi
+
+# --- Linux ---
+if [ "$(id -u)" -ne 0 ]; then
+  echo "Error: This script must be run as root (sudo $0)"
+  exit 1
+fi
+
+# --- Chrome / Puppeteer dependencies ---
+echo ""
+echo "Installing Chrome dependencies for browser preview..."
+
+CHROME_PKGS=(
+  libatk1.0-0 libatk-bridge2.0-0 libcups2 libatspi2.0-0
+  libxcomposite1 libxdamage1 libxfixes3 libxrandr2
+  libgbm1 libcairo2 libpango-1.0-0
+)
+
+# ffmpeg is used for encoding screen recordings to WebM
+RECORDING_PKGS=(
+  ffmpeg
+)
+
+if command -v apt-get &>/dev/null; then
+  # libasound2 was renamed to libasound2t64 in Ubuntu 24.04+
+  if apt-cache show libasound2t64 &>/dev/null 2>&1; then
+    CHROME_PKGS+=(libasound2t64)
+  else
+    CHROME_PKGS+=(libasound2)
+  fi
+  apt-get install -y "${CHROME_PKGS[@]}" "${RECORDING_PKGS[@]}"
+elif command -v dnf &>/dev/null; then
+  dnf install -y atk at-spi2-atk cups-libs libXcomposite libXdamage \
+    libXfixes libXrandr mesa-libgbm cairo pango alsa-lib \
+    ffmpeg
+elif command -v pacman &>/dev/null; then
+  pacman -S --noconfirm atk at-spi2-atk libcups libxcomposite libxdamage \
+    libxfixes libxrandr mesa cairo pango alsa-lib \
+    ffmpeg
+else
+  echo "Error: No supported package manager found (apt-get, dnf, pacman)."
+  echo "Install Chrome dependencies manually."
+  exit 1
+fi
+
+echo "All dependencies installed (Chrome libs, ffmpeg)."
+
+echo ""
+echo "=== Setup complete ==="
+echo "You can now run: npx atoo-studio"

package/src/serial/native/binding.gyp

@@ -0,0 +1,10 @@
+{
+  "targets": [
+    {
+      "target_name": "pty_pair",
+      "sources": ["pty_pair.c"],
+      "cflags": ["-Wall", "-Wextra", "-O2"],
+      "defines": ["_GNU_SOURCE"]
+    }
+  ]
+}

package/src/serial/native/pty_pair.c

@@ -0,0 +1,222 @@
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#include <node_api.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <termios.h>
+#include <sys/ioctl.h>
+
+// Helper: throw JS error and return NULL
+#define NAPI_THROW(env, msg) do { \
+  napi_throw_error(env, NULL, msg); \
+  return NULL; \
+} while (0)
+
+#define NAPI_CHECK(env, status) do { \
+  if ((status) != napi_ok) { \
+    napi_throw_error(env, NULL, "N-API call failed"); \
+    return NULL; \
+  } \
+} while (0)
+
+// createPtyPair() -> { masterFd: number, slavePath: string }
+static napi_value CreatePtyPair(napi_env env, napi_callback_info info) {
+  (void)info;
+
+  // Open the PTY master
+  int master_fd = posix_openpt(O_RDWR | O_NOCTTY);
+  if (master_fd < 0) {
+    char buf[256];
+    snprintf(buf, sizeof(buf), "posix_openpt failed: %s", strerror(errno));
+    NAPI_THROW(env, buf);
+  }
+
+  if (grantpt(master_fd) < 0) {
+    close(master_fd);
+    NAPI_THROW(env, "grantpt failed");
+  }
+
+  if (unlockpt(master_fd) < 0) {
+    close(master_fd);
+    NAPI_THROW(env, "unlockpt failed");
+  }
+
+  char *slave_name = ptsname(master_fd);
+  if (!slave_name) {
+    close(master_fd);
+    NAPI_THROW(env, "ptsname failed");
+  }
+
+  // Open slave briefly to configure raw mode, then close
+  int slave_fd = open(slave_name, O_RDWR | O_NOCTTY);
+  if (slave_fd >= 0) {
+    struct termios tio;
+    if (tcgetattr(slave_fd, &tio) == 0) {
+      cfmakeraw(&tio);
+      tcsetattr(slave_fd, TCSANOW, &tio);
+    }
+    close(slave_fd);
+  }
+
+  // Also set raw mode on master side
+  struct termios mtio;
+  if (tcgetattr(master_fd, &mtio) == 0) {
+    cfmakeraw(&mtio);
+    tcsetattr(master_fd, TCSANOW, &mtio);
+  }
+
+  // Set master fd to non-blocking
+  int flags = fcntl(master_fd, F_GETFL);
+  if (flags >= 0) {
+    fcntl(master_fd, F_SETFL, flags | O_NONBLOCK);
+  }
+
+  // Build result object
+  napi_value result, fd_val, path_val;
+  NAPI_CHECK(env, napi_create_object(env, &result));
+  NAPI_CHECK(env, napi_create_int32(env, master_fd, &fd_val));
+  NAPI_CHECK(env, napi_create_string_utf8(env, slave_name, NAPI_AUTO_LENGTH, &path_val));
+  NAPI_CHECK(env, napi_set_named_property(env, result, "masterFd", fd_val));
+  NAPI_CHECK(env, napi_set_named_property(env, result, "slavePath", path_val));
+
+  return result;
+}
+
+// getModemBits(masterFd: number) -> { dtr: boolean, rts: boolean }
+static napi_value GetModemBits(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value argv[1];
+  NAPI_CHECK(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+  if (argc < 1) NAPI_THROW(env, "getModemBits requires masterFd argument");
+
+  int32_t fd;
+  NAPI_CHECK(env, napi_get_value_int32(env, argv[0], &fd));
+
+  int bits = 0;
+  if (ioctl(fd, TIOCMGET, &bits) < 0) {
+    // PTYs may not support TIOCMGET — return defaults
+    bits = 0;
+  }
+
+  napi_value result, dtr_val, rts_val;
+  NAPI_CHECK(env, napi_create_object(env, &result));
+  NAPI_CHECK(env, napi_get_boolean(env, (bits & TIOCM_DTR) != 0, &dtr_val));
+  NAPI_CHECK(env, napi_get_boolean(env, (bits & TIOCM_RTS) != 0, &rts_val));
+  NAPI_CHECK(env, napi_set_named_property(env, result, "dtr", dtr_val));
+  NAPI_CHECK(env, napi_set_named_property(env, result, "rts", rts_val));
+
+  return result;
+}
+
+// setModemBits(masterFd: number, dtr: boolean, rts: boolean) -> void
+// Used to set modem bits on the master (so slave-side tools see them)
+static napi_value SetModemBits(napi_env env, napi_callback_info info) {
+  size_t argc = 3;
+  napi_value argv[3];
+  NAPI_CHECK(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+  if (argc < 3) NAPI_THROW(env, "setModemBits requires (masterFd, dtr, rts)");
+
+  int32_t fd;
+  bool dtr, rts;
+  NAPI_CHECK(env, napi_get_value_int32(env, argv[0], &fd));
+  NAPI_CHECK(env, napi_get_value_bool(env, argv[1], &dtr));
+  NAPI_CHECK(env, napi_get_value_bool(env, argv[2], &rts));
+
+  int bits = 0;
+  if (dtr) bits |= TIOCM_DTR;
+  if (rts) bits |= TIOCM_RTS;
+
+  ioctl(fd, TIOCMSET, &bits);  // May fail on PTYs - that's OK
+
+  return NULL;
+}
+
+// readMaster(masterFd: number, buffer: Buffer) -> number (bytes read, 0 if EAGAIN, -1 if closed)
+static napi_value ReadMaster(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
+  napi_value argv[2];
+  NAPI_CHECK(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+  if (argc < 2) NAPI_THROW(env, "readMaster requires (masterFd, buffer)");
+
+  int32_t fd;
+  NAPI_CHECK(env, napi_get_value_int32(env, argv[0], &fd));
+
+  void *buf;
+  size_t buf_len;
+  NAPI_CHECK(env, napi_get_buffer_info(env, argv[1], &buf, &buf_len));
+
+  ssize_t n = read(fd, buf, buf_len);
+  int32_t result_val;
+  if (n < 0) {
+    result_val = (errno == EAGAIN || errno == EWOULDBLOCK) ? 0 : -1;
+  } else {
+    result_val = (int32_t)n;
+  }
+
+  napi_value result;
+  NAPI_CHECK(env, napi_create_int32(env, result_val, &result));
+  return result;
+}
+
+// writeMaster(masterFd: number, buffer: Buffer, length: number) -> number (bytes written)
+static napi_value WriteMaster(napi_env env, napi_callback_info info) {
+  size_t argc = 3;
+  napi_value argv[3];
+  NAPI_CHECK(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+  if (argc < 3) NAPI_THROW(env, "writeMaster requires (masterFd, buffer, length)");
+
+  int32_t fd, length;
+  NAPI_CHECK(env, napi_get_value_int32(env, argv[0], &fd));
+
+  void *buf;
+  size_t buf_len;
+  NAPI_CHECK(env, napi_get_buffer_info(env, argv[1], &buf, &buf_len));
+  NAPI_CHECK(env, napi_get_value_int32(env, argv[2], &length));
+
+  size_t to_write = (size_t)length < buf_len ? (size_t)length : buf_len;
+  ssize_t n = write(fd, buf, to_write);
+
+  napi_value result;
+  NAPI_CHECK(env, napi_create_int32(env, n < 0 ? -1 : (int32_t)n, &result));
+  return result;
+}
+
+// closeFd(fd: number) -> void
+static napi_value CloseFd(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value argv[1];
+  NAPI_CHECK(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+  if (argc < 1) NAPI_THROW(env, "closeFd requires fd argument");
+
+  int32_t fd;
+  NAPI_CHECK(env, napi_get_value_int32(env, argv[0], &fd));
+
+  close(fd);
+  return NULL;
+}
+
+// Module init
+static napi_value Init(napi_env env, napi_value exports) {
+  napi_property_descriptor props[] = {
+    {"createPtyPair", NULL, CreatePtyPair, NULL, NULL, NULL, napi_default, NULL},
+    {"getModemBits", NULL, GetModemBits, NULL, NULL, NULL, napi_default, NULL},
+    {"setModemBits", NULL, SetModemBits, NULL, NULL, NULL, napi_default, NULL},
+    {"readMaster", NULL, ReadMaster, NULL, NULL, NULL, napi_default, NULL},
+    {"writeMaster", NULL, WriteMaster, NULL, NULL, NULL, napi_default, NULL},
+    {"closeFd", NULL, CloseFd, NULL, NULL, NULL, napi_default, NULL},
+  };
+  NAPI_CHECK(env, napi_define_properties(env, exports, sizeof(props) / sizeof(props[0]), props));
+  return exports;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)