@shieldbattery/danimoth 0.0.0-stage → 0.1.1

package/native/src/names.rs

@@ -0,0 +1,103 @@
+//! Conversions between the SDK's enum values and the names `index.d.ts` uses for them.
+// The SDK's constants keep their C names (see `sys.rs`).
+#![allow(non_upper_case_globals)]
+
+use neon::prelude::*;
+
+use crate::sys::*;
+
+pub fn client_status_name(status: Discord_Client_Status) -> &'static str {
+    match status {
+        Discord_Client_Status_Disconnected => "disconnected",
+        Discord_Client_Status_Connecting => "connecting",
+        Discord_Client_Status_Connected => "connected",
+        Discord_Client_Status_Ready => "ready",
+        Discord_Client_Status_Reconnecting => "reconnecting",
+        Discord_Client_Status_Disconnecting => "disconnecting",
+        Discord_Client_Status_HttpWait => "httpWait",
+        _ => "unknown",
+    }
+}
+
+pub fn client_error_name(error: Discord_Client_Error) -> &'static str {
+    match error {
+        Discord_Client_Error_None => "none",
+        Discord_Client_Error_ConnectionFailed => "connectionFailed",
+        Discord_Client_Error_UnexpectedClose => "unexpectedClose",
+        Discord_Client_Error_ConnectionCanceled => "connectionCanceled",
+        _ => "unknown",
+    }
+}
+
+pub fn error_type_name(error_type: Discord_ErrorType) -> &'static str {
+    match error_type {
+        Discord_ErrorType_None => "none",
+        Discord_ErrorType_NetworkError => "networkError",
+        Discord_ErrorType_HTTPError => "httpError",
+        Discord_ErrorType_ClientNotReady => "clientNotReady",
+        Discord_ErrorType_Disabled => "disabled",
+        Discord_ErrorType_ClientDestroyed => "clientDestroyed",
+        Discord_ErrorType_ValidationError => "validationError",
+        Discord_ErrorType_Aborted => "aborted",
+        Discord_ErrorType_AuthorizationFailed => "authorizationFailed",
+        Discord_ErrorType_RPCError => "rpcError",
+        _ => "unknown",
+    }
+}
+
+pub fn log_severity_name(severity: Discord_LoggingSeverity) -> &'static str {
+    match severity {
+        Discord_LoggingSeverity_Verbose => "verbose",
+        Discord_LoggingSeverity_Info => "info",
+        Discord_LoggingSeverity_Warning => "warning",
+        Discord_LoggingSeverity_Error => "error",
+        _ => "unknown",
+    }
+}
+
+pub fn parse_log_severity(cx: &mut Cx, name: &str) -> NeonResult<Discord_LoggingSeverity> {
+    match name {
+        "verbose" => Ok(Discord_LoggingSeverity_Verbose),
+        "info" => Ok(Discord_LoggingSeverity_Info),
+        "warning" => Ok(Discord_LoggingSeverity_Warning),
+        "error" => Ok(Discord_LoggingSeverity_Error),
+        _ => cx.throw_type_error(format!("Unknown log severity: {name}")),
+    }
+}
+
+pub fn parse_activity_type(cx: &mut Cx, name: &str) -> NeonResult<Discord_ActivityTypes> {
+    match name {
+        "playing" => Ok(Discord_ActivityTypes_Playing),
+        "streaming" => Ok(Discord_ActivityTypes_Streaming),
+        "listening" => Ok(Discord_ActivityTypes_Listening),
+        "watching" => Ok(Discord_ActivityTypes_Watching),
+        "competing" => Ok(Discord_ActivityTypes_Competing),
+        _ => cx.throw_type_error(format!("Unknown activity type: {name}")),
+    }
+}
+
+pub fn parse_status_display_type(
+    cx: &mut Cx,
+    name: &str,
+) -> NeonResult<Discord_StatusDisplayTypes> {
+    match name {
+        "name" => Ok(Discord_StatusDisplayTypes_Name),
+        "state" => Ok(Discord_StatusDisplayTypes_State),
+        "details" => Ok(Discord_StatusDisplayTypes_Details),
+        _ => cx.throw_type_error(format!("Unknown status display type: {name}")),
+    }
+}
+
+pub fn parse_platform(cx: &mut Cx, name: &str) -> NeonResult<Discord_ActivityGamePlatforms> {
+    match name {
+        "desktop" => Ok(Discord_ActivityGamePlatforms_Desktop),
+        "xbox" => Ok(Discord_ActivityGamePlatforms_Xbox),
+        "samsung" => Ok(Discord_ActivityGamePlatforms_Samsung),
+        "ios" => Ok(Discord_ActivityGamePlatforms_IOS),
+        "android" => Ok(Discord_ActivityGamePlatforms_Android),
+        "embedded" => Ok(Discord_ActivityGamePlatforms_Embedded),
+        "ps4" => Ok(Discord_ActivityGamePlatforms_PS4),
+        "ps5" => Ok(Discord_ActivityGamePlatforms_PS5),
+        _ => cx.throw_type_error(format!("Unknown platform: {name}")),
+    }
+}

package/native/src/sys.rs

@@ -0,0 +1,364 @@
+//! The parts of the Discord Social SDK's C API (`cdiscord.h`) this module uses, loaded from the SDK
+//! DLL at runtime so the module builds without the SDK present.
+//!
+//! The declarations are written by hand against SDK 1.10. They must match `cdiscord.h` exactly:
+//! check every signature here against the header when moving to a new SDK version. C enums are
+//! declared as `i32` rather than Rust enums, since a newer SDK may pass values this module doesn't
+//! know about.
+#![allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+
+use std::ffi::c_void;
+use std::path::Path;
+use std::ptr;
+
+use libloading::Library;
+use libloading::os::windows::{LOAD_WITH_ALTERED_SEARCH_PATH, Library as WindowsLibrary};
+
+/// A string the SDK reads (when passed in) or allocates (when handed back). Strings the SDK hands
+/// back must be released with `Discord_Free`.
+#[repr(C)]
+pub struct Discord_String {
+    pub ptr: *mut u8,
+    pub size: usize,
+}
+
+impl Discord_String {
+    /// Borrows `s` for the duration of a call. The SDK copies strings it keeps.
+    pub fn borrow(s: &str) -> Self {
+        Self {
+            ptr: s.as_ptr() as *mut u8,
+            size: s.len(),
+        }
+    }
+
+    pub fn empty() -> Self {
+        Self {
+            ptr: ptr::null_mut(),
+            size: 0,
+        }
+    }
+}
+
+macro_rules! handles {
+    ($($name:ident),* $(,)?) => {$(
+        /// An SDK object handle. Objects this module creates are wrapped in `Owned`.
+        #[repr(C)]
+        pub struct $name {
+            opaque: *mut c_void,
+        }
+
+        impl Default for $name {
+            fn default() -> Self {
+                Self { opaque: ptr::null_mut() }
+            }
+        }
+    )*};
+}
+
+handles!(
+    Discord_Client,
+    Discord_ClientResult,
+    Discord_Activity,
+    Discord_ActivityAssets,
+    Discord_ActivityTimestamps,
+    Discord_ActivityParty,
+    Discord_ActivitySecrets,
+    Discord_ActivityButton,
+);
+
+/// An SDK object this module created, dropped through the SDK when it goes out of scope.
+///
+/// The handle is a pointer to SDK-owned memory, so moving it is fine.
+pub struct Owned<T> {
+    raw: T,
+    drop: unsafe extern "C" fn(*mut T),
+}
+
+impl<T: Default> Owned<T> {
+    /// # Safety
+    ///
+    /// `init` and `drop` must be the SDK's init and drop functions for `T`.
+    pub unsafe fn new(
+        init: unsafe extern "C" fn(*mut T),
+        drop: unsafe extern "C" fn(*mut T),
+    ) -> Self {
+        let mut raw = T::default();
+        unsafe { init(&mut raw) };
+        Self { raw, drop }
+    }
+
+    /// # Safety
+    ///
+    /// `raw` must be an SDK object whose ownership the SDK handed to the caller, and `drop` the
+    /// SDK's drop function for `T`.
+    pub unsafe fn from_raw(raw: T, drop: unsafe extern "C" fn(*mut T)) -> Self {
+        Self { raw, drop }
+    }
+
+    pub fn as_ptr(&mut self) -> *mut T {
+        &mut self.raw
+    }
+}
+
+impl<T> Drop for Owned<T> {
+    fn drop(&mut self) {
+        unsafe { (self.drop)(&mut self.raw) }
+    }
+}
+
+pub type Discord_FreeFn = unsafe extern "C" fn(ptr: *mut c_void);
+
+pub type Discord_ActivityPartyPrivacy = i32;
+pub const Discord_ActivityPartyPrivacy_Private: i32 = 0;
+pub const Discord_ActivityPartyPrivacy_Public: i32 = 1;
+
+pub type Discord_ActivityTypes = i32;
+pub const Discord_ActivityTypes_Playing: i32 = 0;
+pub const Discord_ActivityTypes_Streaming: i32 = 1;
+pub const Discord_ActivityTypes_Listening: i32 = 2;
+pub const Discord_ActivityTypes_Watching: i32 = 3;
+pub const Discord_ActivityTypes_Competing: i32 = 5;
+
+pub type Discord_StatusDisplayTypes = i32;
+pub const Discord_StatusDisplayTypes_Name: i32 = 0;
+pub const Discord_StatusDisplayTypes_State: i32 = 1;
+pub const Discord_StatusDisplayTypes_Details: i32 = 2;
+
+/// A bit set of `Discord_ActivityGamePlatforms_*` values.
+pub type Discord_ActivityGamePlatforms = i32;
+pub const Discord_ActivityGamePlatforms_Desktop: i32 = 1;
+pub const Discord_ActivityGamePlatforms_Xbox: i32 = 2;
+pub const Discord_ActivityGamePlatforms_Samsung: i32 = 4;
+pub const Discord_ActivityGamePlatforms_IOS: i32 = 8;
+pub const Discord_ActivityGamePlatforms_Android: i32 = 16;
+pub const Discord_ActivityGamePlatforms_Embedded: i32 = 32;
+pub const Discord_ActivityGamePlatforms_PS4: i32 = 64;
+pub const Discord_ActivityGamePlatforms_PS5: i32 = 128;
+
+pub type Discord_ErrorType = i32;
+pub const Discord_ErrorType_None: i32 = 0;
+pub const Discord_ErrorType_NetworkError: i32 = 1;
+pub const Discord_ErrorType_HTTPError: i32 = 2;
+pub const Discord_ErrorType_ClientNotReady: i32 = 3;
+pub const Discord_ErrorType_Disabled: i32 = 4;
+pub const Discord_ErrorType_ClientDestroyed: i32 = 5;
+pub const Discord_ErrorType_ValidationError: i32 = 6;
+pub const Discord_ErrorType_Aborted: i32 = 7;
+pub const Discord_ErrorType_AuthorizationFailed: i32 = 8;
+pub const Discord_ErrorType_RPCError: i32 = 9;
+
+pub type Discord_Client_Error = i32;
+pub const Discord_Client_Error_None: i32 = 0;
+pub const Discord_Client_Error_ConnectionFailed: i32 = 1;
+pub const Discord_Client_Error_UnexpectedClose: i32 = 2;
+pub const Discord_Client_Error_ConnectionCanceled: i32 = 3;
+
+pub type Discord_Client_Status = i32;
+pub const Discord_Client_Status_Disconnected: i32 = 0;
+pub const Discord_Client_Status_Connecting: i32 = 1;
+pub const Discord_Client_Status_Connected: i32 = 2;
+pub const Discord_Client_Status_Ready: i32 = 3;
+pub const Discord_Client_Status_Reconnecting: i32 = 4;
+pub const Discord_Client_Status_Disconnecting: i32 = 5;
+pub const Discord_Client_Status_HttpWait: i32 = 6;
+
+pub type Discord_AuthorizationTokenType = i32;
+pub const Discord_AuthorizationTokenType_Bearer: i32 = 1;
+
+pub type Discord_LoggingSeverity = i32;
+pub const Discord_LoggingSeverity_Verbose: i32 = 1;
+pub const Discord_LoggingSeverity_Info: i32 = 2;
+pub const Discord_LoggingSeverity_Warning: i32 = 3;
+pub const Discord_LoggingSeverity_Error: i32 = 4;
+
+// Callbacks that hand over a `Discord_ClientResult*` give ownership of it to the callee, which must
+// drop it. Strings they hand over must be released with `Discord_Free`.
+pub type Discord_Client_LogCallback = unsafe extern "C" fn(
+    message: Discord_String,
+    severity: Discord_LoggingSeverity,
+    user_data: *mut c_void,
+);
+pub type Discord_Client_OnStatusChanged = unsafe extern "C" fn(
+    status: Discord_Client_Status,
+    error: Discord_Client_Error,
+    error_detail: i32,
+    user_data: *mut c_void,
+);
+pub type Discord_Client_TokenExpirationCallback = unsafe extern "C" fn(user_data: *mut c_void);
+pub type Discord_Client_ActivityJoinCallback =
+    unsafe extern "C" fn(join_secret: Discord_String, user_data: *mut c_void);
+/// The shape shared by `Discord_Client_UpdateTokenCallback` and
+/// `Discord_Client_UpdateRichPresenceCallback`.
+pub type Discord_Client_ResultCallback =
+    unsafe extern "C" fn(result: *mut Discord_ClientResult, user_data: *mut c_void);
+
+macro_rules! sdk_functions {
+    ($($name:ident: fn($($arg:ty),* $(,)?) $(-> $ret:ty)?;)*) => {
+        /// The loaded SDK DLL and the functions this module calls in it.
+        pub struct Sdk {
+            _library: Library,
+            $(pub $name: unsafe extern "C" fn($($arg),*) $(-> $ret)?,)*
+        }
+
+        impl Sdk {
+            /// Loads the SDK DLL at `path` and looks up every function this module uses, so a DLL
+            /// that lacks one fails here rather than on first use.
+            ///
+            /// # Safety
+            ///
+            /// Loading a DLL runs its initialization code. `path` must be a Discord Social SDK DLL
+            /// whose C API matches the declarations in this file.
+            pub unsafe fn load(path: &Path) -> Result<Self, libloading::Error> {
+                // LOAD_WITH_ALTERED_SEARCH_PATH resolves the DLL's own dependencies from its
+                // directory first, rather than from the directory of the executable.
+                let library: Library = unsafe {
+                    WindowsLibrary::load_with_flags(path, LOAD_WITH_ALTERED_SEARCH_PATH)?
+                }
+                .into();
+                Ok(Self {
+                    $($name: unsafe {
+                        *library.get(concat!(stringify!($name), "\0").as_bytes())?
+                    },)*
+                    _library: library,
+                })
+            }
+        }
+    };
+}
+
+sdk_functions! {
+    Discord_Free: fn(*mut c_void);
+    Discord_RunCallbacks: fn();
+
+    Discord_ClientResult_Drop: fn(*mut Discord_ClientResult);
+    Discord_ClientResult_ToString: fn(*mut Discord_ClientResult, *mut Discord_String);
+    Discord_ClientResult_Type: fn(*mut Discord_ClientResult) -> Discord_ErrorType;
+    Discord_ClientResult_Error: fn(*mut Discord_ClientResult, *mut Discord_String);
+    Discord_ClientResult_ErrorCode: fn(*mut Discord_ClientResult) -> i32;
+    Discord_ClientResult_Successful: fn(*mut Discord_ClientResult) -> bool;
+    Discord_ClientResult_Retryable: fn(*mut Discord_ClientResult) -> bool;
+    Discord_ClientResult_RetryAfter: fn(*mut Discord_ClientResult) -> f32;
+
+    Discord_ActivityAssets_Init: fn(*mut Discord_ActivityAssets);
+    Discord_ActivityAssets_Drop: fn(*mut Discord_ActivityAssets);
+    Discord_ActivityAssets_SetLargeImage: fn(*mut Discord_ActivityAssets, *mut Discord_String);
+    Discord_ActivityAssets_SetLargeText: fn(*mut Discord_ActivityAssets, *mut Discord_String);
+    Discord_ActivityAssets_SetSmallImage: fn(*mut Discord_ActivityAssets, *mut Discord_String);
+    Discord_ActivityAssets_SetSmallText: fn(*mut Discord_ActivityAssets, *mut Discord_String);
+
+    Discord_ActivityTimestamps_Init: fn(*mut Discord_ActivityTimestamps);
+    Discord_ActivityTimestamps_Drop: fn(*mut Discord_ActivityTimestamps);
+    Discord_ActivityTimestamps_SetStart: fn(*mut Discord_ActivityTimestamps, u64);
+    Discord_ActivityTimestamps_SetEnd: fn(*mut Discord_ActivityTimestamps, u64);
+
+    Discord_ActivityParty_Init: fn(*mut Discord_ActivityParty);
+    Discord_ActivityParty_Drop: fn(*mut Discord_ActivityParty);
+    Discord_ActivityParty_SetId: fn(*mut Discord_ActivityParty, Discord_String);
+    Discord_ActivityParty_SetCurrentSize: fn(*mut Discord_ActivityParty, i32);
+    Discord_ActivityParty_SetMaxSize: fn(*mut Discord_ActivityParty, i32);
+    Discord_ActivityParty_SetPrivacy: fn(*mut Discord_ActivityParty, Discord_ActivityPartyPrivacy);
+
+    Discord_ActivitySecrets_Init: fn(*mut Discord_ActivitySecrets);
+    Discord_ActivitySecrets_Drop: fn(*mut Discord_ActivitySecrets);
+    Discord_ActivitySecrets_SetJoin: fn(*mut Discord_ActivitySecrets, Discord_String);
+
+    Discord_ActivityButton_Init: fn(*mut Discord_ActivityButton);
+    Discord_ActivityButton_Drop: fn(*mut Discord_ActivityButton);
+    Discord_ActivityButton_SetLabel: fn(*mut Discord_ActivityButton, Discord_String);
+    Discord_ActivityButton_SetUrl: fn(*mut Discord_ActivityButton, Discord_String);
+
+    Discord_Activity_Init: fn(*mut Discord_Activity);
+    Discord_Activity_Drop: fn(*mut Discord_Activity);
+    Discord_Activity_AddButton: fn(*mut Discord_Activity, *const Discord_ActivityButton);
+    Discord_Activity_SetType: fn(*mut Discord_Activity, Discord_ActivityTypes);
+    Discord_Activity_SetStatusDisplayType: fn(*mut Discord_Activity, *mut Discord_StatusDisplayTypes);
+    Discord_Activity_SetState: fn(*mut Discord_Activity, *mut Discord_String);
+    Discord_Activity_SetDetails: fn(*mut Discord_Activity, *mut Discord_String);
+    Discord_Activity_SetAssets: fn(*mut Discord_Activity, *mut Discord_ActivityAssets);
+    Discord_Activity_SetTimestamps: fn(*mut Discord_Activity, *mut Discord_ActivityTimestamps);
+    Discord_Activity_SetParty: fn(*mut Discord_Activity, *mut Discord_ActivityParty);
+    Discord_Activity_SetSecrets: fn(*mut Discord_Activity, *mut Discord_ActivitySecrets);
+    Discord_Activity_SetSupportedPlatforms: fn(*mut Discord_Activity, Discord_ActivityGamePlatforms);
+
+    Discord_Client_Init: fn(*mut Discord_Client);
+    Discord_Client_Drop: fn(*mut Discord_Client);
+    Discord_Client_GetVersionMajor: fn() -> i32;
+    Discord_Client_GetVersionMinor: fn() -> i32;
+    Discord_Client_GetVersionPatch: fn() -> i32;
+    Discord_Client_GetVersionHash: fn(*mut Discord_String);
+    Discord_Client_SetApplicationId: fn(*mut Discord_Client, u64);
+    Discord_Client_AddLogCallback: fn(
+        *mut Discord_Client,
+        Discord_Client_LogCallback,
+        Discord_FreeFn,
+        *mut c_void,
+        Discord_LoggingSeverity,
+    );
+    Discord_Client_SetStatusChangedCallback: fn(
+        *mut Discord_Client,
+        Discord_Client_OnStatusChanged,
+        Discord_FreeFn,
+        *mut c_void,
+    );
+    Discord_Client_SetTokenExpirationCallback: fn(
+        *mut Discord_Client,
+        Discord_Client_TokenExpirationCallback,
+        Discord_FreeFn,
+        *mut c_void,
+    );
+    Discord_Client_SetActivityJoinCallback: fn(
+        *mut Discord_Client,
+        Discord_Client_ActivityJoinCallback,
+        Discord_FreeFn,
+        *mut c_void,
+    );
+    Discord_Client_UpdateToken: fn(
+        *mut Discord_Client,
+        Discord_AuthorizationTokenType,
+        Discord_String,
+        Discord_Client_ResultCallback,
+        Discord_FreeFn,
+        *mut c_void,
+    );
+    Discord_Client_Connect: fn(*mut Discord_Client);
+    Discord_Client_Disconnect: fn(*mut Discord_Client);
+    Discord_Client_GetStatus: fn(*mut Discord_Client) -> Discord_Client_Status;
+    Discord_Client_UpdateRichPresence: fn(
+        *mut Discord_Client,
+        *mut Discord_Activity,
+        Discord_Client_ResultCallback,
+        Discord_FreeFn,
+        *mut c_void,
+    );
+    Discord_Client_ClearRichPresence: fn(*mut Discord_Client);
+    Discord_Client_RegisterLaunchCommand: fn(*mut Discord_Client, u64, Discord_String) -> bool;
+}
+
+impl Sdk {
+    /// Copies a string the SDK handed over and releases the SDK's copy.
+    ///
+    /// # Safety
+    ///
+    /// `s` must be a string the SDK allocated and handed to the caller, not yet released.
+    pub unsafe fn take_string(&self, s: Discord_String) -> String {
+        if s.ptr.is_null() {
+            return String::new();
+        }
+        let value = String::from_utf8_lossy(unsafe { std::slice::from_raw_parts(s.ptr, s.size) })
+            .into_owned();
+        unsafe { (self.Discord_Free)(s.ptr as *mut c_void) };
+        value
+    }
+
+    /// Calls an SDK function that writes a newly allocated string to an out-parameter, and returns
+    /// a copy of it.
+    ///
+    /// # Safety
+    ///
+    /// `f` must write a string the SDK allocated (or leave it empty).
+    pub unsafe fn get_string(&self, f: impl FnOnce(*mut Discord_String)) -> String {
+        let mut s = Discord_String::empty();
+        f(&mut s);
+        unsafe { self.take_string(s) }
+    }
+}

package/package.json

@@ -1,6 +1,37 @@
 {
   "name": "@shieldbattery/danimoth",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Rust-based Node.js native module wrapping the Discord Social SDK",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "build": "cd native && cargo-cp-artifact -nc index.node -- cargo build --target=x86_64-pc-windows-msvc --message-format=json-render-diagnostics",
+    "build-debug": "pnpm run build",
+    "build-release": "pnpm run build --release",
+    "tag-prebuild": "node ./tag-prebuild.js",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "test": "cd native && cargo test && cd .. && pnpm run build && pnpm run tag-prebuild && node --test"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ShieldBattery/danimoth.git"
+  },
+  "keywords": [
+    "discord",
+    "rich-presence"
+  ],
+  "bugs": {
+    "url": "https://github.com/ShieldBattery/danimoth/issues"
+  },
+  "homepage": "https://github.com/ShieldBattery/danimoth#readme",
+  "devDependencies": {
+    "cargo-cp-artifact": "^0.1.9",
+    "prettier": "^3.9.10"
+  },
+  "packageManager": "pnpm@12.14.0+sha512.c18ba6d87993d3d164cb5e8948f32b2c06ee854487e06cd8d86781342fb3e5bb4634367034711e86802baa9c37bea906ce1929ad08d70884c97d801df13389a6"
+}

package/tag-prebuild.js

@@ -0,0 +1,16 @@
+const fs = require('fs')
+const path = require('path')
+
+const orig = path.join('.', 'native', 'index.node')
+if (!fs.existsSync(orig)) {
+  throw new Error('there is no ./native/index.node built by Neon to mark as prebuild')
+}
+
+const prebuildDir = path.join('.', 'prebuilds')
+fs.mkdirSync(prebuildDir, { recursive: true })
+const dest = path.join(prebuildDir, 'x64.node')
+fs.copyFile(orig, dest, err => {
+  if (err) {
+    throw err
+  }
+})