@sebastienrousseau/dotfiles 0.2.502 → 0.2.503

package/dot_config/zsh/dot_zshrc.tmpl

@@ -1,688 +0,0 @@
-# .dotfiles (v{{ .dotfiles_version }}) - <https://dotfiles.io>
-# Made With ❤️ in London, United Kingdom
-# Designed by
-# Copyright (c) 2015-2026. All rights reserved.
-# License: MIT
-
-# Performance optimization - skip if not interactive
-[[ -o interactive ]] || return
-
-# Only source once if being re-sourced (in the same shell scope)
-if [[ -v DOTFILES_SOURCED ]]; then
-  return
-fi
-DOTFILES_SOURCED=1
-
-{{- /* Input Validation: Ensure crucial variables are set */ -}}
-{{- if not .chezmoi.homeDir -}}
-  {{- fail "Critical Error: .chezmoi.homeDir is not set!" -}}
-{{- end -}}
-
-{{- if eq .chezmoi.os "darwin" }}
-export FORCE_COLOR_OS="macOS"
-{{- else if eq .chezmoi.os "linux" }}
-export FORCE_COLOR_OS="Linux"
-{{- else if eq .chezmoi.os "windows" }}
-export FORCE_COLOR_OS="Windows"
-{{- end }}
-
-{{- $profile := default "laptop" .profile -}}
-{{- $features := default (dict "zsh" true "nvim" true "tmux" true "gui" true "secrets" true) .features -}}
-{{- $theme := default "big-sur-dark" .theme -}}
-{{- $strict_mode := default false (index . "strict_mode") -}}
-{{- $enabled := list -}}
-{{- range $k, $v := $features }}{{- if $v }}{{- $enabled = append $enabled $k }}{{- end }}{{- end }}
-
-export DOTFILES_PROFILE="{{ $profile }}"
-export DOTFILES_FEATURES="{{ join "," $enabled }}"
-export DOTFILES_THEME="{{ $theme }}"
-: ${DOTFILES_STARTUP_MODE:=full}
-: ${DOTFILES_FAST:=0}
-: ${DOTFILES_ULTRA_FAST:=0}
-: ${DOTFILES_AI:=0}
-: ${DOTFILES_ALIAS_STRICT_MODE:={{ if $strict_mode }}1{{ else }}0{{ end }}}
-: ${DOTFILES_ULTRA_FAST_PROMPT:=1}
-: ${DOTFILES_LAYERS_LOAD:=ondemand}
-: ${DOTFILES_LAYERS_PREWARM:=system,text,api}
-: ${DOTFILES_ALIAS_WRAPPER:={{ if .features.alias_wrapper }}1{{ else }}0{{ end }}}
-
-# Default compinit based on profile (can be overridden by env)
-if [[ -z "${DOTFILES_ENABLE_COMPINIT+x}" ]]; then
-  case "${DOTFILES_PROFILE}" in
-    laptop|desktop) DOTFILES_ENABLE_COMPINIT=1 ;;
-    *) DOTFILES_ENABLE_COMPINIT=0 ;;
-  esac
-fi
-
-# Startup mode override (if explicit mode set and flags not already set)
-if [[ "${DOTFILES_FAST}" == "0" ]] && [[ "${DOTFILES_ULTRA_FAST}" == "0" ]]; then
-  if [[ "${DOTFILES_STARTUP_MODE}" == "fast" ]]; then
-    DOTFILES_FAST=1
-  elif [[ "${DOTFILES_STARTUP_MODE}" == "ultra" ]]; then
-    DOTFILES_ULTRA_FAST=1
-    DOTFILES_FAST=1
-  fi
-fi
-
-# Ultra-fast mode: minimal init (skip rc.d, plugins, prompts, AI, completions)
-if [[ "${DOTFILES_ULTRA_FAST}" == "1" ]]; then
-  export DOTFILES_FAST=1
-  if [[ "${DOTFILES_ULTRA_FAST_PROMPT}" == "1" ]]; then
-    PROMPT='%n@%m:%~%# '
-    RPROMPT=''
-  fi
-  # Ensure no precmd/preexec hooks run in ultra-fast mode
-  precmd_functions=()
-  preexec_functions=()
-  unset -f precmd preexec
-  typeset -aU path
-  return
-fi
-
-# Cached eval helper — sources cached init scripts, regenerates when stale
-# Debug/Trace modes — observability for shell startup
-: ${DOTFILES_DEBUG:=0}
-: ${DOTFILES_TRACE:=0}
-
-if [[ "${DOTFILES_TRACE}" == "1" ]]; then
-  _dotfiles_trace_dir="${XDG_STATE_HOME:-$HOME/.local/state}/dotfiles"
-  mkdir -p "$_dotfiles_trace_dir"
-  exec 3>&2 2>"$_dotfiles_trace_dir/debug.log"
-  PS4='+%D{%s.%6.} %N:%i> '
-  set -x
-fi
-
-if [[ "${DOTFILES_DEBUG}" == "1" ]]; then
-  _dotfiles_debug_start=${EPOCHREALTIME:-$(date +%s.%N)}
-  _dotfiles_debug() {
-    local now=${EPOCHREALTIME:-$(date +%s.%N)}
-    local elapsed
-    elapsed=$(printf '%.0f' "$(( (now - _dotfiles_debug_start) * 1000 ))")
-    printf '[debug %4dms] %s\n' "$elapsed" "$1" >&2
-  }
-  _dotfiles_debug "startup begins"
-else
-  _dotfiles_debug() { :; }
-fi
-
-_SHELL_CACHE="${XDG_CACHE_HOME:-$HOME/.cache}/zsh"
-[[ -d "$_SHELL_CACHE" ]] || mkdir -p "$_SHELL_CACHE"
-
-# Append a timing event to ${XDG_STATE_HOME:-~/.local/state}/dotfiles/eval-timings.jsonl.
-# Read by `dot perf --by-tool` to attribute startup time per tool.
-_cached_eval_log_timing() {
-  emulate -L zsh
-  setopt no_clobber 2>/dev/null && unsetopt no_clobber
-  local label="$1" t0="$2" t1="$3" rc="${4:-0}" shell="${5:-zsh}"
-  local log_dir="${XDG_STATE_HOME:-$HOME/.local/state}/dotfiles"
-  [[ -d "$log_dir" ]] || mkdir -p "$log_dir" 2>/dev/null || return 0
-  local logfile="$log_dir/eval-timings.jsonl"
-  [[ -f "$logfile" ]] || touch "$logfile" 2>/dev/null || return 0
-  local ms_int=0
-  if [[ -n "$t0" && -n "$t1" ]]; then
-    ms_int=$(printf '%.0f' "$(( (t1 - t0) * 1000 ))" 2>/dev/null) || ms_int=0
-  fi
-  printf '{"ts":"%s","shell":"%s","label":"%s","ms":%s,"rc":%s}\n' \
-    "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$shell" "$label" "$ms_int" "$rc" \
-    >> "$logfile" 2>/dev/null || true
-}
-
-# Cache and source a tool's init output, with mtime/realpath/file-arg invalidation.
-#
-# Runs <cmd args...> on cache miss, vets the output for shell-injection
-# patterns, writes atomically, sources, and precompiles via zcompile in
-# the background. Cache invalidates when the binary's mtime is newer,
-# its realpath has changed (PATH-shadow swap), or a file-path argument
-# is newer than the cache.
-#
-# @arg $1 string Cache label (cache file: $_SHELL_CACHE/<label>.zsh)
-# @arg $2..N string Command and args to run on cache miss
-# @env EVALCACHE_DISABLE Set to "true" to bypass cache read AND write
-# @env EVALCACHE_TIMING  Set to "1" to log per-call timing for `dot perf --by-tool`
-# @stdout Sourced cache content
-# @stderr Warning on init failure or suspicious-output rejection
-# @exitcode 0 Cache hit, successful regeneration, or successful bypass
-# @exitcode 1 Suspicious pattern detected in init output
-# @exitcode * Init command's exit code on non-zero return
-_cached_eval() {
-  if [[ "$EVALCACHE_TIMING" != "1" ]]; then
-    _cached_eval_impl "$@"
-    return
-  fi
-  zmodload zsh/datetime 2>/dev/null
-  local _ce_t0="${EPOCHREALTIME:-$(date +%s.%N 2>/dev/null || echo 0)}"
-  _cached_eval_impl "$@"
-  local _ce_rc=$?
-  local _ce_t1="${EPOCHREALTIME:-$(date +%s.%N 2>/dev/null || echo 0)}"
-  _cached_eval_log_timing "${1:-unknown}" "$_ce_t0" "$_ce_t1" "$_ce_rc" "zsh"
-  return $_ce_rc
-}
-
-_cached_eval_impl() {
-  local label=$1; shift
-
-  # Debug bypass: skip cache read AND write entirely.
-  # Set EVALCACHE_DISABLE=true to eval directly without touching cache files.
-  if [[ "$EVALCACHE_DISABLE" == "true" ]]; then
-    eval "$("$@" 2>/dev/null)"
-    return $?
-  fi
-
-  local cache="$_SHELL_CACHE/${label}.zsh"
-  local pin="${cache}.bin"
-  local bin="${commands[$1]}"
-  local real_bin=""
-  [[ -n "$bin" ]] && real_bin=${bin:A}
-
-  # Cache is valid when: it exists non-empty, the binary is not newer than it,
-  # the recorded realpath (if any) still matches the current realpath, and no
-  # file-path argument has been modified since cache write.
-  local cache_valid=1
-  if [[ ! -s "$cache" ]]; then
-    cache_valid=0
-  elif [[ -n "$bin" && "$bin" -nt "$cache" ]]; then
-    cache_valid=0
-  elif [[ -f "$pin" && -n "$real_bin" ]]; then
-    local pinned_real
-    pinned_real=$(<"$pin")
-    [[ -n "$pinned_real" && "$pinned_real" != "$real_bin" ]] && cache_valid=0
-  fi
-  if (( cache_valid )); then
-    local arg
-    for arg in "${@:2}"; do
-      if [[ -f "$arg" && "$arg" -nt "$cache" ]]; then
-        cache_valid=0
-        break
-      fi
-    done
-  fi
-
-  if (( cache_valid )); then
-    source "$cache"
-    return
-  fi
-
-  local init_output rc
-  init_output=$("$@" 2>/dev/null)
-  rc=$?
-  if (( rc != 0 )); then
-    print -u2 "[WARN] $label init exited $rc; not caching"
-    return $rc
-  fi
-
-  # Reject suspicious patterns indicating malicious payloads
-  local suspicious_re='(curl[[:space:]].*\|[[:space:]]*(ba)?sh|wget[[:space:]].*\|[[:space:]]*(ba)?sh|nc[[:space:]]+-e|/dev/tcp/|base64[[:space:]]+-d[[:space:]]*\|)'
-  if printf '%s\n' "$init_output" | LC_ALL=C grep -Eqs -- "$suspicious_re"; then
-    print -u2 "[WARN] Suspicious output from $label init, skipping"
-    return 1
-  fi
-
-  # `mktemp` instead of `${cache}.tmp.$$` — under PID recycling (very
-  # rare but possible) two concurrent shells with the same $$ could
-  # otherwise race on the same temp file. mktemp gives a unique name.
-  # Use `>|` so we overwrite the just-created mktemp file even when the
-  # user has `setopt noclobber` (see dot_config/shell/05-core-safety.sh).
-  local _tmp _tmp_pin
-  _tmp="$(mktemp "${cache}.XXXXXX")" || return 1
-  print -r -- "$init_output" >| "$_tmp" && mv "$_tmp" "$cache" || { rm -f "$_tmp"; return 1; }
-  if [[ -n "$real_bin" ]]; then
-    _tmp_pin="$(mktemp "${pin}.XXXXXX")" || return 1
-    print -r -- "$real_bin" >| "$_tmp_pin" && mv "$_tmp_pin" "$pin" || { rm -f "$_tmp_pin"; return 1; }
-  fi
-  source "$cache"
-  { zcompile "$cache" } &!
-}
-
-# Clear cache files written by _cached_eval.
-#
-# Safe by design: only deletes *.zsh / *.zsh.bin / *.zwc files in
-# $_SHELL_CACHE, leaving any unrelated content untouched.
-#
-# @noargs
-# @stdout Single-line summary: "Cleared N cached eval file(s) from <dir>"
-# @exitcode 0 Always (no-op when cache dir doesn't exist)
-_cached_eval_clear() {
-  local cache_dir="$_SHELL_CACHE"
-  [[ -d "$cache_dir" ]] || return 0
-  local count=0 f
-  for f in "$cache_dir"/*.zsh(N) "$cache_dir"/*.zsh.bin(N) "$cache_dir"/*.zwc(N); do
-    rm -f -- "$f" && (( count++ ))
-  done
-  printf 'Cleared %d cached eval file(s) from %s\n' "$count" "$cache_dir"
-}
-
-# Lazy-load helper for user-supplied slow tools.
-#
-# Usage in ~/.config/zsh/rc.d/99-local.zsh:
-#   _dot_lazy nvm nvm node npm npx               # nvm.sh sourced on first nvm/node/npm/npx call
-#   _dot_lazy pyenv pyenv python python3 pip pip3
-#   _dot_lazy conda conda
-#
-# First arg is the "trigger" — also the function name that bootstraps
-# the real tool. Remaining args are the commands that, when invoked,
-# bootstrap the trigger then re-exec the command. Bootstrap functions
-# must export `_DOT_LAZY_<TRIGGER>_LOADED` so subsequent calls bypass
-# the stub.
-#
-# Why this matters: every `eval "$(slowtool init zsh)"` at startup
-# costs 50-200ms; lazy-load defers that to first use, keeping
-# `dot version` cold-start under 100ms.
-_dot_lazy() {
-  local trigger="$1"; shift || return 1
-  local cmd
-  for cmd in "$trigger" "$@"; do
-    # shellcheck disable=SC2139,SC2140
-    eval "$cmd() {
-      local _trigger=\"$trigger\"
-      local _loaded_var=\"_DOT_LAZY_\${(U)_trigger//[^A-Z0-9]/_}_LOADED\"
-      if [[ -z \${(P)_loaded_var} ]]; then
-        # Unset every stub so the real binary takes over.
-        local _c
-        for _c in \"$trigger\" $@; do
-          unset -f -- \"\$_c\" 2>/dev/null
-        done
-        # User must define a __dot_lazy_init_<trigger> bootstrap.
-        local _init=\"__dot_lazy_init_\${_trigger//-/_}\"
-        if (( \${+functions[\$_init]} )); then
-          \"\$_init\" || return \$?
-        fi
-        export \"\$_loaded_var=1\"
-      fi
-      command \"$cmd\" \"\$@\"
-    }"
-  done
-}
-
-# Lightweight precmd hook manager (faster than add-zsh-hook)
-_dotfiles_add_precmd() {
-  local fn="$1"
-  [[ -z "$fn" ]] && return 0
-  precmd_functions=(${precmd_functions:#$fn} "$fn")
-}
-
-_dotfiles_del_precmd() {
-  local fn="$1"
-  [[ -z "$fn" ]] && return 0
-  precmd_functions=(${precmd_functions:#$fn})
-}
-
-# ==============================================================================
-# Dotfiles 2026: Zero-Jank & Artifact-Only Mode Foundation
-# ==============================================================================
-export DOTFILES_ARTIFACT_MODE="${DOTFILES_ARTIFACT_MODE:-0}"
-
-if [[ "$DOTFILES_ARTIFACT_MODE" == "1" ]]; then
-  # The Canvas: Strip away all visual noise.
-  export PROMPT="%F{green}➜ %f"
-  export RPROMPT=""
-  # Suppress all background job notifications
-  setopt NO_NOTIFY
-  setopt NO_MONITOR
-fi
-# ==============================================================================
-
-# Lightweight preexec hook manager
-_dotfiles_add_preexec() {
-  local fn="$1"
-  [[ -z "$fn" ]] && return 0
-  preexec_functions=(${preexec_functions:#$fn} "$fn")
-}
-
-_dotfiles_del_preexec() {
-  local fn="$1"
-  [[ -z "$fn" ]] && return 0
-  preexec_functions=(${preexec_functions:#$fn})
-}
-
-## 🆅🅰🆁🅸🅰🆁🅸🅰🅱🅻🅴🆂 - Core variables, plugins, and options
-ZSH_RC_DIR="${HOME}/.config/zsh/rc.d"
-if [[ -d "${ZSH_RC_DIR}" ]]; then
-  for rc_file in "${ZSH_RC_DIR}"/**/*.zsh(N); do
-    source "${rc_file}"
-  done
-fi
-
-# User-local rc.d extensions (not managed by chezmoi)
-if [[ -d "${ZDOTDIR:-$HOME/.config/zsh}/rc.d.local" ]]; then
-  for _rc_local in "${ZDOTDIR:-$HOME/.config/zsh}"/rc.d.local/*.zsh(N); do
-    source "$_rc_local"
-  done
-  unset _rc_local
-fi
-
-###############################
-# Performance: Auto-Zcompile  #
-###############################
-zcompile_many() {
-  local f
-  for f; do
-    # Compile if source is newer than .zwc or .zwc doesn't exist
-    if [[ -f "$f" ]]; then
-      if [[ ! -f "${f}.zwc" || "$f" -nt "${f}.zwc" ]]; then
-        zcompile "$f"
-      fi
-    fi
-  done
-}
-
-# Compile main config and generated files in background
-if [[ -o interactive ]]; then
-  (
-    zcompile_many "${HOME}/.zshrc" \
-                  "${HOME}/.config/shell/aliases.sh" \
-                  "${HOME}/.config/shell/paths.sh" \
-                  "${HOME}/.config/shell/functions.sh" \
-                  "${HOME}/.config/shell/00-core-paths.sh" \
-                  "${HOME}/.config/shell/05-core-safety.sh" \
-                  "${HOME}/.config/shell/40-ls-colors.sh" \
-                  "${HOME}/.config/shell/50-logic-functions-core.sh" \
-                  "${HOME}/.config/shell/90-ux-aliases.sh" \
-                  /opt/homebrew/opt/fzf/shell/completion.zsh \
-                  /opt/homebrew/opt/fzf/shell/key-bindings.zsh &
-  )
-fi
-
-# Legacy Loader (Disabled in favor of Chezmoi Universal Config)
-# _DOTFILES_CACHE="${HOME}/.zsh_dotfiles_cache"
-# load_dotfiles() { ... }
-# load_dotfiles
-
-# Remove duplicates in zsh $PATH
-typeset -aU path
-
-# Load local customizations if they exist
-[[ -f "${HOME}/.zshrc.local" ]] && source "${HOME}/.zshrc.local"
-
-# Vendor / Enterprise Hooks (Site-local overrides)
-# Supports drop-in configs from system management tools
-if [[ -d "/etc/dotfiles/defaults.d" ]]; then
-  for hook in /etc/dotfiles/defaults.d/*.sh(N); do
-    source "$hook"
-  done
-fi
-
-# Load Chezmoi-managed Universal Configuration Layers (Lexical Order)
-# 00-19: Core (Paths, Safety)
-# 20-49: Middleware (Exports, Options)
-# 50-89: Toolchain & Logic (Functions, Rust tools)
-# 90-99: UX (Aliases, Prompts)
-#
-# Optimized loading of core configurations + eager aliases
-if [[ "${DOTFILES_FAST}" == "1" ]]; then
-  _core_layers=(00-core-paths 05-core-safety)
-else
-  _core_layers=(00-core-paths 05-core-safety 90-ux-aliases)
-fi
-for core_layer in "${_core_layers[@]}"; do
-  [[ -f "${HOME}/.config/shell/${core_layer}.sh" ]] && source "${HOME}/.config/shell/${core_layer}.sh"
-done
-unset _core_layers
-
-# Starship prompt (eager — must survive cache clears for consistent UI)
-if [[ "$DOTFILES_ARTIFACT_MODE" != "1" ]] && (( ${+commands[starship]} )); then
-  _cached_eval starship-init starship init zsh
-  # Transient Prompt: collapse the prompt of past commands to the
-  # [character] glyph after Enter, reducing scrollback noise.
-  #
-  # Forward-compatibility hook. Starship's `enable_transience` function
-  # is currently defined only by `starship init fish` (upstream issue
-  # starship/starship#3522 tracks the zsh equivalent). On zsh the
-  # `${+functions[enable_transience]}` guard evaluates to 0, so the
-  # block silently no-ops. When upstream ships the zsh-side function,
-  # this code activates automatically — no zshrc change needed.
-  #
-  # The `_DOTFILES_STARSHIP_TRANSIENT` flag prevents the lazy-hydration
-  # path below (which also re-runs starship init) from binding the
-  # widgets twice.
-  if [[ -z "${_DOTFILES_STARSHIP_TRANSIENT:-}" ]] && (( ${+functions[enable_transience]} )); then
-    enable_transience
-    _DOTFILES_STARSHIP_TRANSIENT=1
-  fi
-fi
-
-# User-local modules (aliases, functions — not managed by chezmoi)
-for _mod_dir in "${XDG_CONFIG_HOME:-$HOME/.config}/dotfiles/modules.d"/*(N/); do
-  for _mod_file in "$_mod_dir"/*.sh(N); do
-    source "$_mod_file"
-  done
-done
-unset _mod_dir _mod_file
-
-if [[ "${DOTFILES_FAST}" != "1" ]]; then
-  # On-demand loading of heavy layers (functions + aliases only when needed)
-  DOTFILES_LAYERS_LOADED=0
-  DOTFILES_LAYERS_LOAD_STATE=idle
-  unset DOTFILES_LAYERS_LOAD_STATUS
-  _dotfiles_load_heavy_layers_stage1() {
-    [[ "${DOTFILES_LAYERS_LOAD_STATE}" == "stage1" || "${DOTFILES_LAYERS_LOAD_STATE}" == "ready" ]] && return 0
-    DOTFILES_LAYERS_LOAD_STATE=loading
-    unset DOTFILES_LAYERS_LOAD_STATUS
-    [[ -f "${HOME}/.config/shell/10-secrets.sh" ]] && source "${HOME}/.config/shell/10-secrets.sh"
-    [[ -f "${HOME}/.config/shell/40-ls-colors.sh" ]] && source "${HOME}/.config/shell/40-ls-colors.sh"
-    [[ -f "${HOME}/.config/shell/50-logic-functions-core.sh" ]] && source "${HOME}/.config/shell/50-logic-functions-core.sh"
-    [[ -f "${HOME}/.config/shell/91-ux-aliases-lazy.sh" ]] && source "${HOME}/.config/shell/91-ux-aliases-lazy.sh"
-    DOTFILES_LAYERS_LOAD_STATE=stage1
-  }
-
-  _dotfiles_load_heavy_layers_stage2() {
-    [[ "${DOTFILES_LAYERS_LOAD_STATE}" == "ready" ]] && return 0
-    [[ -f "${HOME}/.config/shell/51-logic-functions-extra.sh" ]] && source "${HOME}/.config/shell/51-logic-functions-extra.sh"
-    # Compile extra functions for faster future loads
-    if command -v zcompile >/dev/null 2>&1; then
-      { [[ ! -f "${HOME}/.config/shell/51-logic-functions-extra.sh.zwc" || "${HOME}/.config/shell/51-logic-functions-extra.sh" -nt "${HOME}/.config/shell/51-logic-functions-extra.sh.zwc" ]] && zcompile "${HOME}/.config/shell/51-logic-functions-extra.sh" } &!
-    fi
-    DOTFILES_LAYERS_LOAD_STATE=ready
-    DOTFILES_LAYERS_LOAD_STATUS=ready
-    export DOTFILES_LAYERS_LOAD_STATUS
-  }
-
-  _dotfiles_prewarm_groups() {
-    local -a _groups
-    _groups=(${(s:,:)DOTFILES_LAYERS_PREWARM})
-    local g
-    for g in "${_groups[@]}"; do
-      [[ -z "$g" ]] && continue
-      if (( ${+functions[_dotfiles_load_group_${g}]} )); then
-        "_dotfiles_load_group_${g}"
-      fi
-    done
-  }
-
-  _dotfiles_load_heavy_layers() {
-    [[ "${DOTFILES_LAYERS_LOADED}" == "1" ]] && return 0
-    DOTFILES_LAYERS_LOADED=1
-    _dotfiles_load_heavy_layers_stage1
-    _dotfiles_load_heavy_layers_stage2
-  }
-
-  # Optional background prewarm for heavy layers (idle after first prompt)
-  _dotfiles_schedule_heavy_layers() {
-    if [[ "${DOTFILES_LAYERS_LOAD}" == "background" ]]; then
-      if [[ -n "${ZSH_EXECUTION_STRING:-}" ]]; then
-          (sleep 1; _dotfiles_load_heavy_layers_stage1; _dotfiles_load_heavy_layers_stage2; _dotfiles_prewarm_groups) &
-      else
-        zmodload zsh/sched 2>/dev/null || return 0
-        sched +1 _dotfiles_load_heavy_layers_stage1
-        sched +2 _dotfiles_load_heavy_layers_stage2
-        # Prewarm selected groups after stage2 loads stubs
-        sched +3 _dotfiles_prewarm_groups
-      fi
-    fi
-  }
-  # Compatibility: use add-zsh-hook when available (tests rely on this)
-  autoload -Uz add-zsh-hook
-  _load_deferred_layers() {
-    if (( ${+functions[add-zsh-hook]} )); then
-      add-zsh-hook -d precmd _load_deferred_layers
-    else
-      _dotfiles_del_precmd _load_deferred_layers
-    fi
-    _dotfiles_schedule_heavy_layers
-  }
-  if (( ${+functions[add-zsh-hook]} )); then
-    add-zsh-hook precmd _load_deferred_layers
-  else
-    _dotfiles_add_precmd _load_deferred_layers
-  fi
-
-  # Capture existing command_not_found handler (if any)
-  if (( ${+functions[command_not_found_handler]} )); then
-    functions[_dotfiles_prev_command_not_found_handler]="${functions[command_not_found_handler]}"
-  fi
-
-  command_not_found_handler() {
-    local cmd="$1"
-    shift || true
-
-    if [[ "${DOTFILES_LAYERS_LOADED}" != "1" ]]; then
-      _dotfiles_load_heavy_layers_stage1
-      if (( ${+functions[$cmd]} )); then
-        "$cmd" "$@"
-        return $?
-      fi
-      if alias "$cmd" >/dev/null 2>&1; then
-        local -a _args
-        _args=("$@")
-        eval "$cmd ${(@q)_args}"
-        unset _args
-        return $?
-      fi
-      _dotfiles_load_heavy_layers_stage2
-      if (( ${+functions[$cmd]} )); then
-        "$cmd" "$@"
-        return $?
-      fi
-      if alias "$cmd" >/dev/null 2>&1; then
-        local -a _args2
-        _args2=("$@")
-        eval "$cmd ${(@q)_args2}"
-        unset _args2
-        return $?
-      fi
-    fi
-
-    if (( ${+functions[_dotfiles_prev_command_not_found_handler]} )); then
-      _dotfiles_prev_command_not_found_handler "$cmd" "$@"
-      return $?
-    fi
-
-    print -r -- "zsh: command not found: ${cmd}" >&2
-    return 127
-  }
-
-  # dot load: force heavy layers now
-  unalias dot 2>/dev/null
-  functions[dot]='
-    if [[ "$1" == "load" ]]; then
-      if [[ "$2" == "--background" ]]; then
-        DOTFILES_LAYERS_LOAD=background
-        _dotfiles_schedule_heavy_layers
-        return 0
-      fi
-      if [[ "$2" == "--status" ]]; then
-        if [[ "$3" == "--watch" ]]; then
-          local _timeout="${4:-5}"
-          local _t0=$EPOCHREALTIME
-          if [[ "${DOTFILES_LAYERS_LOAD_STATE:-idle}" == "idle" ]]; then
-            _dotfiles_load_heavy_layers
-          fi
-          while [[ "${DOTFILES_LAYERS_LOAD_STATE:-idle}" != "ready" ]]; do
-            sleep 0.1
-            if [[ -n "${_timeout}" && "${_timeout}" != "0" ]]; then
-              local _t1=$EPOCHREALTIME
-              if (( (_t1 - _t0) >= _timeout )); then
-                print -r -- "timeout"
-                return 124
-              fi
-            fi
-          done
-        fi
-        print -r -- "${DOTFILES_LAYERS_LOAD_STATE:-idle}"
-        return 0
-      fi
-      _dotfiles_load_heavy_layers
-      return 0
-    fi
-    "$HOME/.local/bin/dot" "$@"
-  '
-fi
-
-# Essential Aliases (fallback if 90-ux-aliases.sh is unavailable)
-if command -v bat >/dev/null; then
-  alias cat="bat"
-fi
-
-
-if [[ "${DOTFILES_FAST}" != "1" ]]; then
-  ## AI / Predictive Shell (opt-in)
-  if [[ "${DOTFILES_AI}" == "1" ]]; then
-    [[ -f "$HOME/.config/shell/custom/context_suggest.zsh" ]] && source "$HOME/.config/shell/custom/context_suggest.zsh"
-    [[ -f "$HOME/.config/shell/custom/error_analysis.zsh" ]] && source "$HOME/.config/shell/custom/error_analysis.zsh"
-  fi
-
-: ${DOTFILES_DEFER_TOOLS:=1}
-
-# Dotfiles 2026 Async Loader: Move heavy binary path resolution to background
-_dotfiles_async_init() {
-  [[ "$DOTFILES_FAST" == "1" ]] && return
-  local tools=(mise atuin starship zoxide)
-  local t
-  for t in $tools; do
-    if [[ -x "${commands[$t]}" ]]; then
-      case "$t" in
-        mise)
-          _cached_eval mise-init mise activate zsh
-          ;;
-        atuin)
-          _cached_eval atuin-init atuin init zsh
-          ;;
-        starship)
-          if [[ "$DOTFILES_ARTIFACT_MODE" == "0" ]]; then
-            _cached_eval starship-init starship init zsh
-            if [[ -z "${_DOTFILES_STARSHIP_TRANSIENT:-}" ]] && (( ${+functions[enable_transience]} )); then
-              enable_transience
-              _DOTFILES_STARSHIP_TRANSIENT=1
-            fi
-          fi
-          ;;
-        zoxide)
-          _cached_eval zoxide-init zoxide init zsh
-          ;;
-      esac
-    fi
-  done
-  # mise/atuin/etc emit `export PATH=...` which bypasses zsh's -U flag on
-  # the `path` array — re-apply uniqueness to drop any duplicates baked
-  # into the cached output (e.g. system paths inherited from a dirty
-  # parent shell).
-  typeset -U path
-}
-
-# Deferred Hydration for Zero-Jank Experience
-_dotfiles_deferred_hydration() {
-  # Unregister self
-  _dotfiles_del_precmd _dotfiles_deferred_hydration
-  _dotfiles_del_preexec _dotfiles_deferred_hydration
-
-  # Check if already hydrated in this shell instance
-  [[ -n "$DOTFILES_HYDRATED" ]] && return 0
-  export DOTFILES_HYDRATED=1
-
-  _dotfiles_async_init
-
-  # Bento-Grid 2.0 (Liquid Glass Dashboard)
-  # Only render if interactive and not in restricted ultra-fast mode
-  if [[ "$DOTFILES_ARTIFACT_MODE" == "1" ]]; then
-    [[ -f "$HOME/.dotfiles/scripts/dot/lib/bento.sh" ]] && (bash "$HOME/.dotfiles/scripts/dot/lib/bento.sh" </dev/null; kill -WINCH $$) &!
-  fi
-}
-
-# 1. Idle trigger (500ms)
-zmodload zsh/sched 2>/dev/null
-sched +1 _dotfiles_deferred_hydration 2>/dev/null
-
-# 2. First-action trigger (Prompt or Enter)
-_dotfiles_add_precmd _dotfiles_deferred_hydration
-_dotfiles_add_preexec _dotfiles_deferred_hydration
-
-fi