Org-export-in-background doom related error

### I confirm that...

- [X] I have searched the [issue tracker](https://github.com/doomemacs/doomemacs/issues), [documentation](https://docs.doomemacs.org), [FAQ](https://docs.doomemacs.org/-/faq), [Discourse](https://discourse.doomemacs.org), and [Google](https://google.com), in case this issue has already been reported/resolved.
- [X] I have read "[How to Debug Issues](https://doomemacs.org/d/how2debug)", and will use it to provide as much information about this issue as possible.
- [X] The issue can be reproduced on the **latest** available commit of Doom.
- [X] The issue can be reproduced on a stable release of Emacs, such as 27, 28, or 29. *(Unstable versions end in .50, .60, or .9x)*

### Expected behavior

Setting `org-export-in-background` to true would export the document in the background

### Current behavior

An error is raised related to `doom-ensure-straight`, here is the trace:

```
Error: wrong-type-argument (stringp nil)
mapbacktrace(#f(compiled-function (evald func args flags) #))
debug-early-backtrace()
debug-early(error (wrong-type-argument stringp nil))
string-match("^.*/\\(.+\\)\\.git$" nil)
(if (string-match regexp repo) (progn (match-string 1 repo)))
(let ((regexp "^.*/\\(.+\\)\\.git$")) (if (string-match regexp repo) (progn (match-string 1 repo))))
(if host (replace-regexp-in-string "^.+/" "" repo) (let ((regexp "^.*/\\(.+\\)\\.git$")) (if (string-match regexp repo) (progn (match-string 1 repo)))))
(let* ((--cl-rest-- recipe) (repo (car (cdr (plist-member --cl-rest-- ':repo)))) (host (car (cdr (plist-member --cl-rest-- ':host))))) (if host (replace-regexp-in-string "^.+/" "" repo) (let ((regexp "^.*/\\(.+\\)\\.git$")) (if (string-match regexp repo) (progn (match-string 1 repo))))))
straight-vc-git-local-repo-name((:files ("*.el" "*.info" "dir" "doc" "etc" "images" "latex" "style") :package "auctex" :type git))
apply(straight-vc-git-local-repo-name (:files ("*.el" "*.info" "dir" "doc" "etc" "images" "latex" "style") :package "auctex" :type git))
(let ((func (intern (format "straight-vc-%S-%S" type method)))) (if (fboundp func) nil (let ((regexp (format "^straight-vc-%S-[a-z-]+$" type))) (if (catch '--cl-block-nil-- (prog1 nil (mapatoms #'(lambda (sym) (if (and (fboundp sym) (string-match-p regexp (symbol-name sym))) (progn (throw '--cl-block-nil-- t))))))) (error "VC backend `%S' does not implement method `%S'" type method) (error "No such VC backend `%S'" type)))) (apply func args))
straight-vc(local-repo-name git (:files ("*.el" "*.info" "dir" "doc" "etc" "images" "latex" "style") :package "auctex" :type git))
(let* ((--cl-rest-- recipe) (type (car (cdr (plist-member --cl-rest-- ':type))))) (straight-vc 'local-repo-name type recipe))
straight-vc-local-repo-name((:files ("*.el" "*.info" "dir" "doc" "etc" "images" "latex" "style") :package "auctex" :type git))
(or (straight-vc-local-repo-name plist) package)
(plist-put plist :local-repo (or (straight-vc-local-repo-name plist) package))
(setq plist (plist-put plist :local-repo (or (straight-vc-local-repo-name plist) package)))
(progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :local-repo (or (straight-vc-local-repo-name plist) package))))
(if (or (plist-member plist :local-repo) (eq (plist-get plist :type) 'built-in)) nil (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :local-repo (or (straight-vc-local-repo-name plist) package)))))
(let ((package (symbol-name package))) (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :package package))) (if (plist-member plist :type) nil (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :type straight-default-vc)))) (if (or (plist-member plist :local-repo) (eq (plist-get plist :type) 'built-in)) nil (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :local-repo (or (straight-vc-local-repo-name plist) package))))) (if recipe-specified-p nil (let* ((--cl-rest-- plist) (local-repo (car (cdr (plist-member --cl-rest-- ':local-repo))))) (let* ((original-recipe (and t (gethash local-repo straight--repo-cache)))) (if original-recipe (progn (let ((props (cons :type (straight-vc-keywords (plist-get plist :type))))) (setq plist (let* ((--cl-var-- plist) (prop nil) (val nil) (--cl-var--) (--cl-var-- nil)) (while (consp --cl-var--) (progn (setq --cl-var-- --cl-var--) (setq prop (car-safe (prog1 --cl-var-- (setq --cl-var-- (cdr --cl-var--))))) (setq val (car --cl-var--))) (if (memq prop props) (progn) (setq --cl-var-- (cons prop --cl-var--)) (setq --cl-var-- (cons val --cl-var--))) (setq --cl-var-- (cdr (cdr --cl-var--)))) (nreverse --cl-var--)))) (let ((tail (cons :type (straight-vc-keywords (plist-get original-recipe :type))))) (while tail (let ((keyword (car tail))) (let* ((value (and t (plist-get original-recipe keyword)))) (if value (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist keyword value))) nil)) (setq tail (cdr tail)))))) nil)))) plist)
(progn (let* ((inherit (plist-member plist :inherit)) (inheritance (if inherit (car (cdr inherit)) straight-allow-recipe-inheritance))) (if inheritance (progn (let* ((sources (plist-get plist :source)) (default (or (let* ((retrieved (and t (straight-recipes-retrieve package (if (listp sources) sources (list sources)))))) (if retrieved (cdr (if (straight--quoted-form-p retrieved) (eval retrieved) retrieved)) nil)) plist)) (type (if (plist-member default :type) (plist-get default :type) straight-default-vc)) (keywords (append straight--build-keywords (straight-vc-keywords type)))) (let* ((fork (and t (plist-get plist :fork)))) (if fork (progn (progn (setq default (copy-sequence default)) (setq default (plist-put default :fork fork))) (if (listp fork) nil (setq fork 'nil)) (progn (setq fork (copy-sequence fork)) (setq fork (plist-put fork :repo (straight-vc-git--fork-repo default)))) (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :fork fork)))) nil)) (let ((tail keywords)) (while tail (let ((keyword (car tail))) (if (plist-member plist keyword) nil (let* ((value (and t (plist-get default keyword)))) (if value (setq plist (plist-put plist keyword value)) nil))) (setq tail (cdr tail))))))))) (let ((package (symbol-name package))) (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :package package))) (if (plist-member plist :type) nil (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :type straight-default-vc)))) (if (or (plist-member plist :local-repo) (eq (plist-get plist :type) 'built-in)) nil (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :local-repo (or (straight-vc-local-repo-name plist) package))))) (if recipe-specified-p nil (let* ((--cl-rest-- plist) (local-repo (car (cdr (plist-member --cl-rest-- ':local-repo))))) (let* ((original-recipe (and t (gethash local-repo straight--repo-cache)))) (if original-recipe (progn (let ((props (cons :type (straight-vc-keywords (plist-get plist :type))))) (setq plist (let* ((--cl-var-- plist) (prop nil) (val nil) (--cl-var--) (--cl-var-- nil)) (while (consp --cl-var--) (progn (setq --cl-var-- --cl-var--) (setq prop (car-safe (prog1 --cl-var-- (setq --cl-var-- (cdr --cl-var--))))) (setq val (car --cl-var--))) (if (memq prop props) (progn) (setq --cl-var-- (cons prop --cl-var--)) (setq --cl-var-- (cons val --cl-var--))) (setq --cl-var-- (cdr (cdr --cl-var--)))) (nreverse --cl-var--)))) (let ((tail (cons :type (straight-vc-keywords (plist-get original-recipe :type))))) (while tail (let ((keyword (car tail))) (let* ((value (and t (plist-get original-recipe keyword)))) (if value (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist keyword value))) nil)) (setq tail (cdr tail)))))) nil)))) plist))
(let* ((plist full-melpa-style-recipe) (package (if plist (car-safe (prog1 plist (setq plist (cdr plist)))) (signal 'wrong-number-of-arguments (list '(package . plist) (length plist)))))) (progn (let* ((inherit (plist-member plist :inherit)) (inheritance (if inherit (car (cdr inherit)) straight-allow-recipe-inheritance))) (if inheritance (progn (let* ((sources (plist-get plist :source)) (default (or (let* ((retrieved (and t (straight-recipes-retrieve package (if (listp sources) sources (list sources)))))) (if retrieved (cdr (if (straight--quoted-form-p retrieved) (eval retrieved) retrieved)) nil)) plist)) (type (if (plist-member default :type) (plist-get default :type) straight-default-vc)) (keywords (append straight--build-keywords (straight-vc-keywords type)))) (let* ((fork (and t (plist-get plist :fork)))) (if fork (progn (progn (setq default (copy-sequence default)) (setq default (plist-put default :fork fork))) (if (listp fork) nil (setq fork 'nil)) (progn (setq fork (copy-sequence fork)) (setq fork (plist-put fork :repo (straight-vc-git--fork-repo default)))) (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :fork fork)))) nil)) (let ((tail keywords)) (while tail (let ((keyword (car tail))) (if (plist-member plist keyword) nil (let* ((value (and t (plist-get default keyword)))) (if value (setq plist (plist-put plist keyword value)) nil))) (setq tail (cdr tail))))))))) (let ((package (symbol-name package))) (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :package package))) (if (plist-member plist :type) nil (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :type straight-default-vc)))) (if (or (plist-member plist :local-repo) (eq (plist-get plist :type) 'built-in)) nil (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :local-repo (or (straight-vc-local-repo-name plist) package))))) (if recipe-specified-p nil (let* ((--cl-rest-- plist) (local-repo (car (cdr (plist-member --cl-rest-- ':local-repo))))) (let* ((original-recipe (and t (gethash local-repo straight--repo-cache)))) (if original-recipe (progn (let ((props (cons :type (straight-vc-keywords (plist-get plist :type))))) (setq plist (let* ((--cl-var-- plist) (prop nil) (val nil) (--cl-var--) (--cl-var-- nil)) (while (consp --cl-var--) (progn (setq --cl-var-- --cl-var--) (setq prop (car-safe (prog1 --cl-var-- (setq --cl-var-- (cdr --cl-var--))))) (setq val (car --cl-var--))) (if (memq prop props) (progn) (setq --cl-var-- (cons prop --cl-var--)) (setq --cl-var-- (cons val --cl-var--))) (setq --cl-var-- (cdr (cdr --cl-var--)))) (nreverse --cl-var--)))) (let ((tail (cons :type (straight-vc-keywords (plist-get original-recipe :type))))) (while tail (let ((keyword (car tail))) (let* ((value (and t (plist-get original-recipe keyword)))) (if value (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist keyword value))) nil)) (setq tail (cdr tail)))))) nil)))) plist)))
(let* ((recipe-specified-p (listp melpa-style-recipe)) (full-melpa-style-recipe (if recipe-specified-p melpa-style-recipe (or (straight-recipes-retrieve melpa-style-recipe nil cause) (if (straight--package-built-in-p melpa-style-recipe) (throw '--cl-block-straight--convert-recipe-- (list ':type 'built-in ':package (symbol-name melpa-style-recipe))) (error (concat "Could not find package %S. " "Updating recipe repositories: %S " "with `straight-pull-recipe-repositories' " "may fix this") melpa-style-recipe straight-recipe-repositories)))))) (if (straight--quoted-form-p full-melpa-style-recipe) (progn (setq full-melpa-style-recipe (eval full-melpa-style-recipe)))) (let* ((plist full-melpa-style-recipe) (package (if plist (car-safe (prog1 plist (setq plist (cdr plist)))) (signal 'wrong-number-of-arguments (list '(package . plist) (length plist)))))) (progn (let* ((inherit (plist-member plist :inherit)) (inheritance (if inherit (car (cdr inherit)) straight-allow-recipe-inheritance))) (if inheritance (progn (let* ((sources (plist-get plist :source)) (default (or (let* ((retrieved (and t (straight-recipes-retrieve package (if (listp sources) sources (list sources)))))) (if retrieved (cdr (if (straight--quoted-form-p retrieved) (eval retrieved) retrieved)) nil)) plist)) (type (if (plist-member default :type) (plist-get default :type) straight-default-vc)) (keywords (append straight--build-keywords (straight-vc-keywords type)))) (let* ((fork (and t (plist-get plist :fork)))) (if fork (progn (progn (setq default (copy-sequence default)) (setq default (plist-put default :fork fork))) (if (listp fork) nil (setq fork 'nil)) (progn (setq fork (copy-sequence fork)) (setq fork (plist-put fork :repo (straight-vc-git--fork-repo default)))) (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :fork fork)))) nil)) (let ((tail keywords)) (while tail (let ((keyword (car tail))) (if (plist-member plist keyword) nil (let* ((value (and t (plist-get default keyword)))) (if value (setq plist (plist-put plist keyword value)) nil))) (setq tail (cdr tail))))))))) (let ((package (symbol-name package))) (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :package package))) (if (plist-member plist :type) nil (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :type straight-default-vc)))) (if (or (plist-member plist :local-repo) (eq (plist-get plist :type) 'built-in)) nil (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :local-repo (or (straight-vc-local-repo-name plist) package))))) (if recipe-specified-p nil (let* ((--cl-rest-- plist) (local-repo (car (cdr (plist-member --cl-rest-- ':local-repo))))) (let* ((original-recipe (and t (gethash local-repo straight--repo-cache)))) (if original-recipe (progn (let ((props (cons :type (straight-vc-keywords (plist-get plist :type))))) (setq plist (let* ((--cl-var-- plist) (prop nil) (val nil) (--cl-var--) (--cl-var-- nil)) (while (consp --cl-var--) (progn (setq --cl-var-- --cl-var--) (setq prop (car-safe (prog1 --cl-var-- (setq --cl-var-- (cdr --cl-var--))))) (setq val (car --cl-var--))) (if (memq prop props) (progn) (setq --cl-var-- (cons prop --cl-var--)) (setq --cl-var-- (cons val --cl-var--))) (setq --cl-var-- (cdr (cdr --cl-var--)))) (nreverse --cl-var--)))) (let ((tail (cons :type (straight-vc-keywords (plist-get original-recipe :type))))) (while tail (let ((keyword (car tail))) (let* ((value (and t (plist-get original-recipe keyword)))) (if value (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist keyword value))) nil)) (setq tail (cdr tail)))))) nil)))) plist))))
(or (and (symbolp melpa-style-recipe) (gethash (symbol-name melpa-style-recipe) straight--recipe-cache)) (let* ((recipe-specified-p (listp melpa-style-recipe)) (full-melpa-style-recipe (if recipe-specified-p melpa-style-recipe (or (straight-recipes-retrieve melpa-style-recipe nil cause) (if (straight--package-built-in-p melpa-style-recipe) (throw '--cl-block-straight--convert-recipe-- (list ':type 'built-in ':package (symbol-name melpa-style-recipe))) (error (concat "Could not find package %S. " "Updating recipe repositories: %S " "with `straight-pull-recipe-repositories' " "may fix this") melpa-style-recipe straight-recipe-repositories)))))) (if (straight--quoted-form-p full-melpa-style-recipe) (progn (setq full-melpa-style-recipe (eval full-melpa-style-recipe)))) (let* ((plist full-melpa-style-recipe) (package (if plist (car-safe (prog1 plist (setq plist (cdr plist)))) (signal 'wrong-number-of-arguments (list '(package . plist) (length plist)))))) (progn (let* ((inherit (plist-member plist :inherit)) (inheritance (if inherit (car (cdr inherit)) straight-allow-recipe-inheritance))) (if inheritance (progn (let* ((sources (plist-get plist :source)) (default (or (let* ((retrieved (and t (straight-recipes-retrieve package (if (listp sources) sources (list sources)))))) (if retrieved (cdr (if (straight--quoted-form-p retrieved) (eval retrieved) retrieved)) nil)) plist)) (type (if (plist-member default :type) (plist-get default :type) straight-default-vc)) (keywords (append straight--build-keywords (straight-vc-keywords type)))) (let* ((fork (and t (plist-get plist :fork)))) (if fork (progn (progn (setq default (copy-sequence default)) (setq default (plist-put default :fork fork))) (if (listp fork) nil (setq fork 'nil)) (progn (setq fork (copy-sequence fork)) (setq fork (plist-put fork :repo (straight-vc-git--fork-repo default)))) (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :fork fork)))) nil)) (let ((tail keywords)) (while tail (let ((keyword (car tail))) (if (plist-member plist keyword) nil (let* ((value (and t (plist-get default keyword)))) (if value (setq plist (plist-put plist keyword value)) nil))) (setq tail (cdr tail))))))))) (let ((package (symbol-name package))) (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :package package))) (if (plist-member plist :type) nil (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :type straight-default-vc)))) (if (or (plist-member plist :local-repo) (eq (plist-get plist :type) 'built-in)) nil (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :local-repo (or (straight-vc-local-repo-name plist) package))))) (if recipe-specified-p nil (let* ((--cl-rest-- plist) (local-repo (car (cdr (plist-member --cl-rest-- ':local-repo))))) (let* ((original-recipe (and t (gethash local-repo straight--repo-cache)))) (if original-recipe (progn (let ((props (cons :type (straight-vc-keywords (plist-get plist :type))))) (setq plist (let* ((--cl-var-- plist) (prop nil) (val nil) (--cl-var--) (--cl-var-- nil)) (while (consp --cl-var--) (progn (setq --cl-var-- --cl-var--) (setq prop (car-safe (prog1 --cl-var-- (setq --cl-var-- (cdr --cl-var--))))) (setq val (car --cl-var--))) (if (memq prop props) (progn) (setq --cl-var-- (cons prop --cl-var--)) (setq --cl-var-- (cons val --cl-var--))) (setq --cl-var-- (cdr (cdr --cl-var--)))) (nreverse --cl-var--)))) (let ((tail (cons :type (straight-vc-keywords (plist-get original-recipe :type))))) (while tail (let ((keyword (car tail))) (let* ((value (and t (plist-get original-recipe keyword)))) (if value (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist keyword value))) nil)) (setq tail (cdr tail)))))) nil)))) plist)))))
(catch '--cl-block-straight--convert-recipe-- (if (memq melpa-style-recipe straight-built-in-pseudo-packages) (progn (throw '--cl-block-straight--convert-recipe-- (list ':type 'built-in ':package (symbol-name melpa-style-recipe))))) (or (and (symbolp melpa-style-recipe) (gethash (symbol-name melpa-style-recipe) straight--recipe-cache)) (let* ((recipe-specified-p (listp melpa-style-recipe)) (full-melpa-style-recipe (if recipe-specified-p melpa-style-recipe (or (straight-recipes-retrieve melpa-style-recipe nil cause) (if (straight--package-built-in-p melpa-style-recipe) (throw '--cl-block-straight--convert-recipe-- (list ':type 'built-in ':package (symbol-name melpa-style-recipe))) (error (concat "Could not find package %S. " "Updating recipe repositories: %S " "with `straight-pull-recipe-repositories' " "may fix this") melpa-style-recipe straight-recipe-repositories)))))) (if (straight--quoted-form-p full-melpa-style-recipe) (progn (setq full-melpa-style-recipe (eval full-melpa-style-recipe)))) (let* ((plist full-melpa-style-recipe) (package (if plist (car-safe (prog1 plist (setq plist (cdr plist)))) (signal 'wrong-number-of-arguments (list '(package . plist) (length plist)))))) (progn (let* ((inherit (plist-member plist :inherit)) (inheritance (if inherit (car (cdr inherit)) straight-allow-recipe-inheritance))) (if inheritance (progn (let* ((sources (plist-get plist :source)) (default (or (let* ((retrieved (and t (straight-recipes-retrieve package (if (listp sources) sources (list sources)))))) (if retrieved (cdr (if (straight--quoted-form-p retrieved) (eval retrieved) retrieved)) nil)) plist)) (type (if (plist-member default :type) (plist-get default :type) straight-default-vc)) (keywords (append straight--build-keywords (straight-vc-keywords type)))) (let* ((fork (and t (plist-get plist :fork)))) (if fork (progn (progn (setq default (copy-sequence default)) (setq default (plist-put default :fork fork))) (if (listp fork) nil (setq fork 'nil)) (progn (setq fork (copy-sequence fork)) (setq fork (plist-put fork :repo (straight-vc-git--fork-repo default)))) (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :fork fork)))) nil)) (let ((tail keywords)) (while tail (let ((keyword (car tail))) (if (plist-member plist keyword) nil (let* ((value (and t (plist-get default keyword)))) (if value (setq plist (plist-put plist keyword value)) nil))) (setq tail (cdr tail))))))))) (let ((package (symbol-name package))) (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :package package))) (if (plist-member plist :type) nil (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :type straight-default-vc)))) (if (or (plist-member plist :local-repo) (eq (plist-get plist :type) 'built-in)) nil (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist :local-repo (or (straight-vc-local-repo-name plist) package))))) (if recipe-specified-p nil (let* ((--cl-rest-- plist) (local-repo (car (cdr (plist-member --cl-rest-- ':local-repo))))) (let* ((original-recipe (and t (gethash local-repo straight--repo-cache)))) (if original-recipe (progn (let ((props (cons :type (straight-vc-keywords (plist-get plist :type))))) (setq plist (let* ((--cl-var-- plist) (prop nil) (val nil) (--cl-var--) (--cl-var-- nil)) (while (consp --cl-var--) (progn (setq --cl-var-- --cl-var--) (setq prop (car-safe (prog1 --cl-var-- (setq --cl-var-- (cdr --cl-var--))))) (setq val (car --cl-var--))) (if (memq prop props) (progn) (setq --cl-var-- (cons prop --cl-var--)) (setq --cl-var-- (cons val --cl-var--))) (setq --cl-var-- (cdr (cdr --cl-var--)))) (nreverse --cl-var--)))) (let ((tail (cons :type (straight-vc-keywords (plist-get original-recipe :type))))) (while tail (let ((keyword (car tail))) (let* ((value (and t (plist-get original-recipe keyword)))) (if value (progn (setq plist (copy-sequence plist)) (setq plist (plist-put plist keyword value))) nil)) (setq tail (cdr tail)))))) nil)))) plist))))))
straight--convert-recipe((auctex :files ("*.el" "*.info" "dir" "doc" "etc" "images" "latex" "style")) nil)
(let ((recipe (straight--convert-recipe (or (straight--get-overridden-recipe (if (listp melpa-style-recipe) (car melpa-style-recipe) melpa-style-recipe)) melpa-style-recipe) cause))) (straight--register-recipe recipe) (let* ((--cl-rest-- recipe) (package (car (cdr (plist-member --cl-rest-- ':package)))) (local-repo (car (cdr (plist-member --cl-rest-- ':local-repo)))) (type (car (cdr (plist-member --cl-rest-- ':type))))) (progn (if (eq type 'built-in) (progn (throw '--cl-block-straight-use-package-- t))) (straight--transaction-exec (intern (format "use-package-%S-%S-%S" (secure-hash 'md5 (prin1-to-string recipe 'noescape)) (if (let ((object no-clone)) (and (not (memq object '(no-clone t))) (functionp object))) (random) no-clone) (if (let ((object no-build)) (and (not (memq object '(no-build t))) (functionp object))) (random) no-build))) :now #'(lambda nil (let ((already-registered (gethash package straight--success-cache)) (available (or (null local-repo) (straight--repository-is-available-p recipe)))) (if (if (let ((object no-clone)) (and (not (memq object '(no-clone t))) (functionp object))) (funcall no-clone package available) no-clone) (progn (throw '--cl-block-straight-use-package-- nil))) (if available nil (straight--clone-repository recipe cause)) (straight--make-build-cache-available) (let* ((no-build (or (null local-repo) (straight--build-disabled-p recipe) (if (let ((object no-build)) (and (not (memq object '(no-build t))) (functionp object))) (funcall no-build package) no-build))) (modified (or (and straight--packages-to-rebuild (or (eq straight--packages-to-rebuild :all) (gethash package straight--packages-to-rebuild)) (not (gethash package straight--packages-not-to-rebuild)) (puthash package t straight--packages-not-to-rebuild)) (straight--package-might-be-modified-p recipe no-build)))) (let ((func (intern (format "straight-recipes-%s-version" package))) (table (gethash (intern package) straight--recipe-lookup-cache))) (if (or modified (not (fboundp func)) (not (equal (and table (gethash 'version table)) (funcall func)))) (progn (remhash (intern package) straight--recipe-lookup-cache)))) (if no-build nil (straight--add-package-to-load-path recipe)) (run-hook-with-args 'straight-use-package-prepare-functions package) (let ((tail '(native-comp-deferred-compilation-deny-list native-comp-jit-compilation-deny-list))) (while tail (let ((list-var (car tail))) (if (boundp list-var) (progn (let* ((build (and t (car (cdr (plist-member recipe :build)))))) (if build (if (and (eq (car-safe build) :not) (member 'native-compile (cdr build))) (progn (set list-var (let* ((va (format "^%s" (straight--build-dir package))) (vlist (symbol-value list-var))) (if (cl-member va vlist :test #'string=) vlist (cons va vlist)))))) nil)))) (setq tail (cdr tail))))) (if (and modified (not no-build)) (progn (run-hook-with-args 'straight-use-package-pre-build-functions package) (straight--build-package recipe cause))) (straight--declare-successful-build recipe) (if no-build nil (let ((tail (straight--get-dependencies package))) (while tail (let ((dependency (car tail))) (straight-use-package (intern dependency) nil nil cause) (setq tail (cdr tail))))) (straight--add-package-to-info-path recipe) (straight--activate-package-autoloads recipe)) (if (and interactive (not already-registered)) (progn (straight--output (concat "If you want to keep %s, put " "(straight-use-package %s%S) " "in your init-file.") package "'" (intern package))))) (puthash package t straight--success-cache) t))))))
(catch '--cl-block-straight-use-package-- (let ((recipe (straight--convert-recipe (or (straight--get-overridden-recipe (if (listp melpa-style-recipe) (car melpa-style-recipe) melpa-style-recipe)) melpa-style-recipe) cause))) (straight--register-recipe recipe) (let* ((--cl-rest-- recipe) (package (car (cdr (plist-member --cl-rest-- ':package)))) (local-repo (car (cdr (plist-member --cl-rest-- ':local-repo)))) (type (car (cdr (plist-member --cl-rest-- ':type))))) (progn (if (eq type 'built-in) (progn (throw '--cl-block-straight-use-package-- t))) (straight--transaction-exec (intern (format "use-package-%S-%S-%S" (secure-hash 'md5 (prin1-to-string recipe 'noescape)) (if (let ((object no-clone)) (and (not (memq object '(no-clone t))) (functionp object))) (random) no-clone) (if (let ((object no-build)) (and (not (memq object '(no-build t))) (functionp object))) (random) no-build))) :now #'(lambda nil (let ((already-registered (gethash package straight--success-cache)) (available (or (null local-repo) (straight--repository-is-available-p recipe)))) (if (if (let ((object no-clone)) (and (not (memq object '(no-clone t))) (functionp object))) (funcall no-clone package available) no-clone) (progn (throw '--cl-block-straight-use-package-- nil))) (if available nil (straight--clone-repository recipe cause)) (straight--make-build-cache-available) (let* ((no-build (or (null local-repo) (straight--build-disabled-p recipe) (if (let ((object no-build)) (and (not (memq object '(no-build t))) (functionp object))) (funcall no-build package) no-build))) (modified (or (and straight--packages-to-rebuild (or (eq straight--packages-to-rebuild :all) (gethash package straight--packages-to-rebuild)) (not (gethash package straight--packages-not-to-rebuild)) (puthash package t straight--packages-not-to-rebuild)) (straight--package-might-be-modified-p recipe no-build)))) (let ((func (intern (format "straight-recipes-%s-version" package))) (table (gethash (intern package) straight--recipe-lookup-cache))) (if (or modified (not (fboundp func)) (not (equal (and table (gethash 'version table)) (funcall func)))) (progn (remhash (intern package) straight--recipe-lookup-cache)))) (if no-build nil (straight--add-package-to-load-path recipe)) (run-hook-with-args 'straight-use-package-prepare-functions package) (let ((tail '(native-comp-deferred-compilation-deny-list native-comp-jit-compilation-deny-list))) (while tail (let ((list-var (car tail))) (if (boundp list-var) (progn (let* ((build (and t (car (cdr (plist-member recipe :build)))))) (if build (if (and (eq (car-safe build) :not) (member 'native-compile (cdr build))) (progn (set list-var (let* ((va (format "^%s" (straight--build-dir package))) (vlist (symbol-value list-var))) (if (cl-member va vlist :test #'string=) vlist (cons va vlist)))))) nil)))) (setq tail (cdr tail))))) (if (and modified (not no-build)) (progn (run-hook-with-args 'straight-use-package-pre-build-functions package) (straight--build-package recipe cause))) (straight--declare-successful-build recipe) (if no-build nil (let ((tail (straight--get-dependencies package))) (while tail (let ((dependency (car tail))) (straight-use-package (intern dependency) nil nil cause) (setq tail (cdr tail))))) (straight--add-package-to-info-path recipe) (straight--activate-package-autoloads recipe)) (if (and interactive (not already-registered)) (progn (straight--output (concat "If you want to keep %s, put " "(straight-use-package %s%S) " "in your init-file.") package "'" (intern package))))) (puthash package t straight--success-cache) t)))))))
straight-use-package(auctex no-clone)
straight-register-package(auctex)
(let ((package (car tail))) (straight-register-package package) (let ((name (symbol-name package))) (add-to-list 'load-path (directory-file-name (straight--build-dir name))) (straight--load-package-autoloads name)) (setq tail (cdr tail)))
(while tail (let ((package (car tail))) (straight-register-package package) (let ((name (symbol-name package))) (add-to-list 'load-path (directory-file-name (straight--build-dir name))) (straight--load-package-autoloads name)) (setq tail (cdr tail))))
(let ((tail (cl-delete-duplicates packages :test #'equal))) (while tail (let ((package (car tail))) (straight-register-package package) (let ((name (symbol-name package))) (add-to-list 'load-path (directory-file-name (straight--build-dir name))) (straight--load-package-autoloads name)) (setq tail (cdr tail)))))
(let (packages) (let ((tail doom-packages)) (while tail (let ((package (car tail))) (let* ((--cl-rest-- package) (name (if --cl-rest-- (car-safe (prog1 --cl-rest-- (setq --cl-rest-- (cdr --cl-rest--)))) (signal 'wrong-number-of-arguments (list '(name &key recipe disable ignore &allow-other-keys) (length --cl-rest--))))) (recipe (car (cdr (plist-member --cl-rest-- ':recipe)))) (disable (car (cdr (plist-member --cl-rest-- ':disable)))) (ignore (car (cdr (plist-member --cl-rest-- ':ignore))))) (if ignore (straight-override-recipe (cons name '(:type built-in))) (if disable (let* ((var name)) (if (memql var doom-disabled-packages) (with-no-warnings doom-disabled-packages) (setq doom-disabled-packages (cons var doom-disabled-packages)))) (if recipe (progn (straight-override-recipe (cons name recipe)))) (setq packages (append packages (cons name (straight--get-dependencies name))))))) (setq tail (cdr tail))))) (let ((tail (cl-delete-duplicates packages :test #'equal))) (while tail (let ((package (car tail))) (straight-register-package package) (let ((name (symbol-name package))) (add-to-list 'load-path (directory-file-name (straight--build-dir name))) (straight--load-package-autoloads name)) (setq tail (cdr tail))))))
(progn (if doom-inhibit-log nil (doom--log "Initializing straight.el")) (progn (setq doom-disabled-packages nil) (setq doom-packages (doom-package-list))) (let (packages) (let ((tail doom-packages)) (while tail (let ((package (car tail))) (let* ((--cl-rest-- package) (name (if --cl-rest-- (car-safe (prog1 --cl-rest-- (setq --cl-rest-- (cdr --cl-rest--)))) (signal 'wrong-number-of-arguments (list '(name &key recipe disable ignore &allow-other-keys) (length --cl-rest--))))) (recipe (car (cdr (plist-member --cl-rest-- ':recipe)))) (disable (car (cdr (plist-member --cl-rest-- ':disable)))) (ignore (car (cdr (plist-member --cl-rest-- ':ignore))))) (if ignore (straight-override-recipe (cons name '(:type built-in))) (if disable (let* ((var name)) (if (memql var doom-disabled-packages) (with-no-warnings doom-disabled-packages) (setq doom-disabled-packages (cons var doom-disabled-packages)))) (if recipe (progn (straight-override-recipe (cons name recipe)))) (setq packages (append packages (cons name (straight--get-dependencies name))))))) (setq tail (cdr tail))))) (let ((tail (cl-delete-duplicates packages :test #'equal))) (while tail (let ((package (car tail))) (straight-register-package package) (let ((name (symbol-name package))) (add-to-list 'load-path (directory-file-name (straight--build-dir name))) (straight--load-package-autoloads name)) (setq tail (cdr tail)))))))
(if (or force-p (null doom-packages)) (progn (if doom-inhibit-log nil (doom--log "Initializing straight.el")) (progn (setq doom-disabled-packages nil) (setq doom-packages (doom-package-list))) (let (packages) (let ((tail doom-packages)) (while tail (let ((package (car tail))) (let* ((--cl-rest-- package) (name (if --cl-rest-- (car-safe (prog1 --cl-rest-- (setq --cl-rest-- (cdr --cl-rest--)))) (signal 'wrong-number-of-arguments (list '(name &key recipe disable ignore &allow-other-keys) (length --cl-rest--))))) (recipe (car (cdr (plist-member --cl-rest-- ':recipe)))) (disable (car (cdr (plist-member --cl-rest-- ':disable)))) (ignore (car (cdr (plist-member --cl-rest-- ':ignore))))) (if ignore (straight-override-recipe (cons name '(:type built-in))) (if disable (let* ((var name)) (if (memql var doom-disabled-packages) (with-no-warnings doom-disabled-packages) (setq doom-disabled-packages (cons var doom-disabled-packages)))) (if recipe (progn (straight-override-recipe (cons name recipe)))) (setq packages (append packages (cons name (straight--get-dependencies name))))))) (setq tail (cdr tail))))) (let ((tail (cl-delete-duplicates packages :test #'equal))) (while tail (let ((package (car tail))) (straight-register-package package) (let ((name (symbol-name package))) (add-to-list 'load-path (directory-file-name (straight--build-dir name))) (straight--load-package-autoloads name)) (setq tail (cdr tail))))))))
doom-initialize-packages()
(closure (t) nil (doom-initialize-packages))()
eval-after-load-helper("/home/casper/.config/emacs/.local/straight/repos/straight.el/straight.el")
do-after-load-evaluation("/home/casper/.config/emacs/.local/straight/repos/straight.el/straight.el")
load-with-code-conversion("/home/casper/.config/emacs/.local/straight/repos/straight.el/straight.el" "/home/casper/.config/emacs/.local/straight/repos/straight.el/straight.el" nil t)
require(straight "/home/casper/.config/emacs/.local/straight/repos/straight.el/straight.el")
(let ((repo-dir (doom-path straight-base-dir "straight/repos/straight.el")) (repo-url (concat "http" (if gnutls-verify-error "s") "://github.com/" (or (plist-get recipe :repo) "radian-software/straight.el"))) (branch (or (plist-get recipe :branch) straight-repository-branch)) (call (if init-file-debug #'(lambda (&rest args) (doom-print (doom-print--format "%s" (cdr (apply #'doom-call-process args))))) #'(lambda (&rest args) (apply #'doom-call-process args))))) (if (file-directory-p repo-dir) nil (let ((saved-match-data (match-data))) (unwind-protect (progn (if (executable-find "git") nil (user-error "Git isn't present on your system. Cannot proceed.")) (let* ((version (cdr (doom-call-process "git" "version"))) (version (and (string-match "\\_<[0-9]+\\.[0-9]+\\(\\.[0-9]+\\)\\_>" version) (match-string 0 version)))) (if version (if (version< version "2.23") (progn (user-error "Git %s detected! Doom requires git 2.23 or newer!" version)))))) (set-match-data saved-match-data t))) (doom-print (doom-print--format (doom-print--class 'start "Installing straight..."))) (progn (let ((doom-print-level (or nil doom-print-level)) (doom-print-indent (+ (if t (or nil doom-print-indent-increment) 0) doom-print-indent))) (let* ((options (ensure-list straight-vc-git-default-clone-depth)) (depth (if options (car-safe (prog1 options (setq options (cdr options)))) (signal 'wrong-number-of-arguments (list '(depth . options) (length options)))))) (let ((branch-switch (if (memq 'single-branch options) "--single-branch" "--no-single-branch"))) (cond ((eq 'full depth) (funcall call "git" "clone" "--origin" "origin" branch-switch repo-url repo-dir)) ((integerp depth) (if (null pin) (progn (if (file-directory-p repo-dir) (progn (delete-directory repo-dir 'recursive))) (funcall call "git" "clone" "--origin" "origin" repo-url "--no-checkout" repo-dir "--depth" (number-to-string depth) branch-switch "--no-tags" "--branch" straight-repository-branch)) (make-directory repo-dir 'recursive) (let ((default-directory repo-dir)) (funcall call "git" "init") (funcall call "git" "branch" "-m" straight-repository-branch) (funcall call "git" "remote" "add" "origin" repo-url "--master" straight-repository-branch) (funcall call "git" "fetch" "origin" pin "--depth" (number-to-string depth) "--no-tags") (funcall call "git" "reset" "--hard" pin)))))))))) (require 'straight (concat repo-dir "/straight.el")) (if doom-inhibit-log nil (doom--log "Initializing recipes")) (mapc #'straight-use-recipes '((org-elpa :local-repo nil) (melpa :type git :host github :repo "melpa/melpa" :build nil) (nongnu-elpa :type git :repo "https://git.savannah.gnu.org/git/emacs/nongnu.git" :local-repo "nongnu-elpa" :build nil) (gnu-elpa-mirror :type git :host github :repo "emacs-straight/gnu-elpa-mirror" :build nil) (el-get :type git :host github :repo "dimitri/el-get" :build nil) (emacsmirror-mirror :type git :host github :repo "emacs-straight/emacsmirror-mirror" :build nil))))
(let ((process-environment (copy-sequence process-environment))) (setenv "GIT_CONFIG" nil) (setenv "GIT_CONFIG_NOSYSTEM" "1") (setenv "GIT_CONFIG_GLOBAL" (or (getenv "DOOMGITCONFIG") "/dev/null")) (let ((repo-dir (doom-path straight-base-dir "straight/repos/straight.el")) (repo-url (concat "http" (if gnutls-verify-error "s") "://github.com/" (or (plist-get recipe :repo) "radian-software/straight.el"))) (branch (or (plist-get recipe :branch) straight-repository-branch)) (call (if init-file-debug #'(lambda (&rest args) (doom-print (doom-print--format "%s" (cdr (apply #'doom-call-process args))))) #'(lambda (&rest args) (apply #'doom-call-process args))))) (if (file-directory-p repo-dir) nil (let ((saved-match-data (match-data))) (unwind-protect (progn (if (executable-find "git") nil (user-error "Git isn't present on your system. Cannot proceed.")) (let* ((version (cdr (doom-call-process "git" "version"))) (version (and (string-match "\\_<[0-9]+\\.[0-9]+\\(\\.[0-9]+\\)\\_>" version) (match-string 0 version)))) (if version (if (version< version "2.23") (progn (user-error "Git %s detected! Doom requires git 2.23 or newer!" version)))))) (set-match-data saved-match-data t))) (doom-print (doom-print--format (doom-print--class 'start "Installing straight..."))) (progn (let ((doom-print-level (or nil doom-print-level)) (doom-print-indent (+ (if t (or nil doom-print-indent-increment) 0) doom-print-indent))) (let* ((options (ensure-list straight-vc-git-default-clone-depth)) (depth (if options (car-safe (prog1 options (setq options (cdr options)))) (signal 'wrong-number-of-arguments (list '(depth . options) (length options)))))) (let ((branch-switch (if (memq 'single-branch options) "--single-branch" "--no-single-branch"))) (cond ((eq 'full depth) (funcall call "git" "clone" "--origin" "origin" branch-switch repo-url repo-dir)) ((integerp depth) (if (null pin) (progn (if (file-directory-p repo-dir) (progn (delete-directory repo-dir 'recursive))) (funcall call "git" "clone" "--origin" "origin" repo-url "--no-checkout" repo-dir "--depth" (number-to-string depth) branch-switch "--no-tags" "--branch" straight-repository-branch)) (make-directory repo-dir 'recursive) (let ((default-directory repo-dir)) (funcall call "git" "init") (funcall call "git" "branch" "-m" straight-repository-branch) (funcall call "git" "remote" "add" "origin" repo-url "--master" straight-repository-branch) (funcall call "git" "fetch" "origin" pin "--depth" (number-to-string depth) "--no-tags") (funcall call "git" "reset" "--hard" pin)))))))))) (require 'straight (concat repo-dir "/straight.el")) (if doom-inhibit-log nil (doom--log "Initializing recipes")) (mapc #'straight-use-recipes '((org-elpa :local-repo nil) (melpa :type git :host github :repo "melpa/melpa" :build nil) (nongnu-elpa :type git :repo "https://git.savannah.gnu.org/git/emacs/nongnu.git" :local-repo "nongnu-elpa" :build nil) (gnu-elpa-mirror :type git :host github :repo "emacs-straight/gnu-elpa-mirror" :build nil) (el-get :type git :host github :repo "dimitri/el-get" :build nil) (emacsmirror-mirror :type git :host github :repo "emacs-straight/emacsmirror-mirror" :build nil)))))
doom--ensure-straight((:host github :repo "radian-software/straight.el" :branch "develop" :local-repo "straight.el" :files ("straight*.el")) "88e574ae75344e39b436f863ef0344135c7b6517")
(let* ((--cl-rest-- (alist-get 'straight packages)) (recipe (car (cdr (plist-member --cl-rest-- ':recipe)))) (pin (car (cdr (plist-member --cl-rest-- ':pin))))) (doom--ensure-straight recipe pin))
(let ((packages (doom-package-list '((:core))))) (let* ((--cl-rest-- (alist-get 'straight packages)) (recipe (car (cdr (plist-member --cl-rest-- ':recipe)))) (pin (car (cdr (plist-member --cl-rest-- ':pin))))) (doom--ensure-straight recipe pin)) (doom--ensure-core-packages (seq-filter #'(lambda (%) (eq (plist-get (cdr %) :type) 'core)) packages)))
(progn (if doom-inhibit-log nil (doom--log "Initializing straight")) (let ((packages (doom-package-list '((:core))))) (let* Wrong type argument: stringp, nil
((--cl-rest-- (alist-get 'straight packages)) (recipe (car (cdr (plist-member --cl-rest-- ':recipe)))) (pin (car (cdr (plist-member --cl-rest-- ':pin))))) (doom--ensure-straight recipe pin)) (doom--ensure-core-packages (seq-filter #'(lambda (%) (eq (plist-get (cdr %) :type) 'core)) packages))))
(if (or force-p (null (and (boundp 'straight-recipe-repositories) straight-recipe-repositories))) (progn (if doom-inhibit-log nil (doom--log "Initializing straight")) (let ((packages (doom-package-list '((:core))))) (let* ((--cl-rest-- (alist-get 'straight packages)) (recipe (car (cdr (plist-member --cl-rest-- ':recipe)))) (pin (car (cdr (plist-member --cl-rest-- ':pin))))) (doom--ensure-straight recipe pin)) (doom--ensure-core-packages (seq-filter #'(lambda (%) (eq (plist-get (cdr %) :type) 'core)) packages)))))
doom-initialize-core-packages(nil)
doom-initialize-packages()
(let (kill-emacs-query-functions kill-emacs-hook) (doom-load init-file 'noerror) (doom-initialize-packages))
(let ((init-file (doom-profile-init-file))) (if (file-exists-p init-file) nil (user-error "Profile init file hasn't been generated. Did you forgot to run 'doom sync'?")) (let (kill-emacs-query-functions kill-emacs-hook) (doom-load init-file 'noerror) (doom-initialize-packages)))
(progn (doom-require 'doom-profiles) (let ((init-file (doom-profile-init-file))) (if (file-exists-p init-file) nil (user-error "Profile init file hasn't been generated. Did you forgot to run 'doom sync'?")) (let (kill-emacs-query-functions kill-emacs-hook) (doom-load init-file 'noerror) (doom-initialize-packages))))
(if noninteractive (progn (doom-require 'doom-profiles) (let ((init-file (doom-profile-init-file))) (if (file-exists-p init-file) nil (user-error "Profile init file hasn't been generated. Did you forgot to run 'doom sync'?")) (let (kill-emacs-query-functions kill-emacs-hook) (doom-load init-file 'noerror) (doom-initialize-packages)))))
load-with-code-conversion("/home/casper/.config/emacs/lisp/doom-start.el" "/home/casper/.config/emacs/lisp/doom-start.el" nil t)
require(doom-start)
(if init-file (load init-file nil t) (load "/home/casper/.config/emacs/early-init.el" nil t) (require 'doom-start))
(let ((init-file nil)) (if init-file (load init-file nil t) (load "/home/casper/.config/emacs/early-init.el" nil t) (require 'doom-start)))
(unwind-protect (let ((init-file nil)) (if init-file (load init-file nil t) (load "/home/casper/.config/emacs/early-init.el" nil t) (require 'doom-start))) (delete-file load-file-name))
load-with-code-conversion("/tmp/doom-org-async-exportxlqPlF" "/tmp/doom-org-async-exportxlqPlF" nil t)
command-line-1(("-l" "/tmp/doom-org-async-exportxlqPlF" "-l" "/tmp/org-export-processa2v87u"))
command-line()
normal-top-level()
```

### Steps to reproduce

set `org-export-in-background` to true and run org-export-to-pdf

### System Information

https://pastebin.com/yRXL0Sc8