# shellcheck shell=bash

do_secure_executables() {
  # pacman's own systemd-sysusers hook only runs after the whole transaction,
  # but this scriptlet starts vibeshine-vkms-control.socket (SocketGroup=
  # vibeshine-vkms) before that. Create both account sets now so a first
  # install does not fail to resolve the group.
  systemd-sysusers /usr/lib/sysusers.d/vibepollo.conf
  systemd-sysusers /usr/lib/sysusers.d/vibeshine-vkms.conf
  local executable client broker host public_identity broker_identity host_identity
  local broker_capabilities host_capabilities
  executable=$(readlink -f /usr/bin/vibepollo) || return 1
  client=/usr/libexec/vibeshine/vibepollo-session-exec
  broker=/usr/libexec/vibeshine/vibepollo-session-broker
  host=/usr/libexec/vibeshine/vibepollo-host
  [[ -f "$executable" && ! -L "$executable" &&
     -f "$client" && ! -L "$client" &&
     -f "$broker" && ! -L "$broker" &&
     -f "$host" && ! -L "$host" ]] || return 1
  chown root:root "$executable" "$client"
  chmod 0755 "$executable" "$client"
  setcap -r "$executable" 2>/dev/null || true
  setcap -r "$client" 2>/dev/null || true
  [[ -z $(getcap "$executable" 2>/dev/null) ]] || {
    echo 'error: unsafe file capabilities remain on the native Vibepollo executable.' >&2
    return 1
  }
  [[ -z $(getcap "$client" 2>/dev/null) ]] || {
    echo 'error: obsolete capabilities remain on the Vibepollo session client.' >&2
    return 1
  }
  chown root:root "$broker"
  chmod 0700 "$broker"
  setcap cap_kill,cap_setgid,cap_setuid=p "$broker" || return 1
  [[ $(stat -c '%U:%G:%a:%F' -- "$broker") == \
     'root:root:700:regular file' ]] || return 1
  broker_capabilities=$(getcap "$broker" 2>/dev/null)
  [[ "$broker_capabilities" == "$broker cap_kill,cap_setgid,cap_setuid=p" ]] || {
    echo 'error: the root-only session broker has unexpected file capabilities.' >&2
    return 1
  }

  public_identity=$(stat -Lc '%d:%i' -- "$executable") || return 1
  broker_identity=$(stat -Lc '%d:%i' -- "$broker") || return 1
  host_identity=$(stat -Lc '%d:%i' -- "$host") || return 1
  [[ "$public_identity" != "$host_identity" && "$broker_identity" != "$host_identity" ]] || {
    echo 'error: privileged broker and private/public hosts must be distinct inodes.' >&2
    return 1
  }
  chown root:vibepollo "$host"
  chmod 0750 "$host"
  setcap cap_sys_admin,cap_sys_nice=p "$host" || return 1
  [[ $(stat -c '%U:%G:%a:%F' -- "$host") == \
     'root:vibepollo:750:regular file' ]] || return 1
  host_capabilities=$(getcap "$host" 2>/dev/null)
  [[ "$host_capabilities" == "$host cap_sys_admin,cap_sys_nice=p" ]] || {
    echo 'error: the private Vibepollo host has unexpected file capabilities.' >&2
    return 1
  }
  [[ $(getcap "$broker" 2>/dev/null) == \
     "$broker cap_kill,cap_setgid,cap_setuid=p" ]] || {
    echo 'error: private-host setup altered the session broker capabilities.' >&2
    return 1
  }
  [[ -z $(getcap "$executable" 2>/dev/null) &&
     -z $(getcap "$client" 2>/dev/null) ]] || {
    echo 'error: a public Vibepollo entrypoint gained file capabilities.' >&2
    return 1
  }
}

readonly vibepollo_controller=/usr/libexec/vibeshine/vibepollo-session-controller
readonly vibepollo_legacy_host=/usr/libexec/vibeshine/vibepollo-machine-host
readonly vibepollo_legacy_handoff=/usr/libexec/vibeshine/vibepollo-session-handoff
readonly vibepollo_runtime_root=/run/vibepollo
readonly vibepollo_broker_socket=/run/vibepollo/session-broker.sock
readonly vibepollo_control_socket=/run/vibeshine/vkms-control.sock
readonly vibepollo_host_upgrade_dropin_dir=/run/systemd/system/vibepollo.service.d
readonly vibepollo_host_upgrade_dropin=$vibepollo_host_upgrade_dropin_dir/90-vibepollo-safe-upgrade.conf
vibepollo_controller_was_frozen=0
vibepollo_upgrade_kill_mode=
readonly vibepollo_legacy_handoff_directory=/run/vibepollo/session-handoffs
readonly vibepollo_legacy_restore_directory=/run/vibepollo/session-restores
readonly vibepollo_legacy_transition_lock=/run/vibepollo/session-handoff.lock
readonly vibepollo_legacy_prelogin_marker=/run/vibepollo/prelogin-handoff-complete

vibepollo_cgroup_is_quiescent() {
  local control_group=$1 cgroup_path
  [[ -n "$control_group" ]] || return 0
  [[ "$control_group" == /* && "$control_group" != */../* && "$control_group" != */.. ]] || return 1
  cgroup_path=/sys/fs/cgroup$control_group
  if [[ ! -e "$cgroup_path" && ! -L "$cgroup_path" ]]; then
    return 0
  fi
  [[ -d "$cgroup_path" && ! -L "$cgroup_path" &&
     -f "$cgroup_path/cgroup.events" && ! -L "$cgroup_path/cgroup.events" ]] &&
    grep -qx 'populated 0' "$cgroup_path/cgroup.events"
}

vibepollo_unit_is_quiescent() {
  local unit=$1 properties line key value
  local load='' state='' substate='' pid='' control_group=''
  local -A seen=()
  properties=$(timeout --signal=KILL 5 systemctl show "$unit" \
    --property=LoadState --property=ActiveState --property=SubState --property=MainPID \
    --property=ControlGroup 2>/dev/null) || return 1
  while IFS= read -r line || [[ -n "$line" ]]; do
    [[ "$line" == *=* ]] || return 1
    key=${line%%=*}
    value=${line#*=}
    [[ "$key" =~ ^(LoadState|ActiveState|SubState|MainPID|ControlGroup)$ &&
       -z ${seen[$key]:-} ]] || return 1
    seen[$key]=1
    case "$key" in
      LoadState) load=$value ;;
      ActiveState) state=$value ;;
      SubState) substate=$value ;;
      MainPID) pid=$value ;;
      ControlGroup) control_group=$value ;;
    esac
  done <<<"$properties"
  [[ -n ${seen[LoadState]:-} && -n ${seen[ActiveState]:-} &&
     -n ${seen[SubState]:-} && -n ${seen[ControlGroup]:-} ]] || return 1
  # Socket units carry no MainPID property, so `systemctl show` omits it.
  if [[ "$unit" == *.socket ]]; then
    ((${#seen[@]} == 4 || ${#seen[@]} == 5)) || return 1
    [[ -z ${seen[MainPID]:-} || "$pid" == 0 ]] || return 1
  else
    ((${#seen[@]} == 5)) || return 1
    [[ "$pid" == 0 ]] || return 1
  fi
  [[ "$load:$state:$substate" =~ ^(not-found:inactive:dead|(loaded|masked|masked-runtime):(inactive:dead|failed:failed))$ ]] || return 1
  vibepollo_cgroup_is_quiescent "$control_group"
}

vibepollo_unit_is_disabled() {
  local enabled
  enabled=$(timeout --signal=KILL 5 systemctl is-enabled "$1" 2>/dev/null || true)
  [[ "$enabled" =~ ^(disabled|masked|masked-runtime|static|indirect|generated|transient|linked|linked-runtime|not-found)$ ]]
}

vibepollo_restore_template_is_masked() {
  local state load
  state=$(timeout --signal=KILL 5 systemctl is-enabled \
    'vibepollo-session-restore@.service' 2>/dev/null || true)
  # systemd 261 rejects a bare template name in `systemctl show` ("neither a
  # valid invocation ID nor unit name"), so probe an instance of the template:
  # an instance of a masked template reports LoadState=masked.
  load=$(timeout --signal=KILL 5 systemctl show 'vibepollo-session-restore@mask-probe.service' \
    --property=LoadState 2>/dev/null) || return 1
  [[ "$state" =~ ^(masked|masked-runtime)$ && "$load" == 'LoadState=masked' ]]
}

vibepollo_host_unit_is_masked() {
  local state load
  state=$(timeout --signal=KILL 5 systemctl is-enabled vibepollo.service 2>/dev/null || true)
  load=$(timeout --signal=KILL 5 systemctl show vibepollo.service \
    --property=LoadState 2>/dev/null) || return 1
  [[ "$state" =~ ^(masked|masked-runtime)$ && "$load" == 'LoadState=masked' ]]
}

vibepollo_broker_socket_is_masked() {
  local state load
  state=$(timeout --signal=KILL 5 systemctl is-enabled \
    vibepollo-session-exec.socket 2>/dev/null || true)
  load=$(timeout --signal=KILL 5 systemctl show vibepollo-session-exec.socket \
    --property=LoadState 2>/dev/null) || return 1
  [[ "$state" =~ ^(masked|masked-runtime)$ && "$load" == 'LoadState=masked' ]]
}

vibepollo_control_socket_is_masked() {
  local state load
  state=$(timeout --signal=KILL 5 systemctl is-enabled \
    vibeshine-vkms-control.socket 2>/dev/null || true)
  load=$(timeout --signal=KILL 5 systemctl show vibeshine-vkms-control.socket \
    --property=LoadState 2>/dev/null) || return 1
  [[ "$state" =~ ^(masked|masked-runtime)$ && "$load" == 'LoadState=masked' ]]
}

vibepollo_restore_unit_is_safe() {
  [[ "$1" =~ ^vibepollo-session-restore@[1-9][0-9]*\.service$ ]]
}

vibepollo_broker_unit_is_safe() {
  [[ "$1" =~ ^vibepollo-session-exec@[A-Za-z0-9_.:-]+\.service$ ]]
}

vibepollo_control_unit_is_safe() {
  [[ "$1" =~ ^vibeshine-vkms-control@[A-Za-z0-9_.:-]+\.service$ ]]
}

vibepollo_stop_exact_unit() {
  # Never bypass a service's ordered resource teardown.  Killing systemctl
  # only abandons the client while its manager job continues; killing the unit
  # cgroup can strand live GPU imports and is therefore forbidden here.
  # Controller cleanup can legitimately spend more than 30 seconds draining
  # the host and GPU bindings; keep waiting for the manager's ordered stop.
  timeout --signal=TERM --kill-after=2 60 systemctl stop "$1" 2>/dev/null
}

vibepollo_capture_unit_list() {
  local path=$1 pattern=$2 size
  [[ -f "$path" && ! -L "$path" ]] || return 1
  chmod 0600 "$path" || return 1
  (
    ulimit -f 128 || exit 1
    timeout --signal=KILL 5 systemctl list-units --all --plain --no-legend \
      --no-pager --full "$pattern" >"$path" 2>/dev/null
  ) || return 1
  size=$(stat -c '%s' -- "$path") || return 1
  [[ "$size" =~ ^[0-9]+$ && "$size" -le 65536 ]]
}

vibepollo_control_instances_are_quiescent() (
  local list unit load state substate line dirty attempt=0 clean_passes=0
  local -a fields=()
  local -A seen=()
  list=$(mktemp /run/vibepollo-control-units.XXXXXX) || exit 1
  trap 'rm -f -- "$list"' EXIT
  trap 'exit 1' HUP INT TERM
  while ((attempt < 100)); do
    dirty=0
    seen=()
    vibepollo_capture_unit_list "$list" 'vibeshine-vkms-control@*.service' || return 1
    while IFS= read -r line || [[ -n "$line" ]]; do
      [[ -n "$line" && "$line" != *$'\r'* ]] || { [[ -z "$line" ]] && continue; return 1; }
      read -ra fields <<<"$line"
      [[ ${fields[0]:-} == '●' ]] && fields=("${fields[@]:1}")
      ((${#fields[@]} >= 4)) || return 1
      unit=${fields[0]}; load=${fields[1]}; state=${fields[2]}; substate=${fields[3]}
      vibepollo_control_unit_is_safe "$unit" && [[ "$load" == loaded ]] || return 1
      [[ "$state:$substate" =~ ^[a-z-]+:[a-z-]+$ && -z ${seen[$unit]:-} ]] || return 1
      seen[$unit]=1
      ((${#seen[@]} <= 256)) || return 1
      vibepollo_unit_is_quiescent "$unit" || dirty=1
    done <"$list"
    if ((dirty == 0)); then
      ((clean_passes += 1))
      if ((clean_passes >= 5)); then
        [[ ! -e "$vibepollo_control_socket" && ! -L "$vibepollo_control_socket" ]]
        return
      fi
    else
      clean_passes=0
    fi
    ((attempt += 1))
    sleep 0.1
  done
  return 1
)

vibepollo_select_upgrade_kill_mode() {
  if [[ ! -e "$vibepollo_legacy_host" && ! -L "$vibepollo_legacy_host" ]]; then
    vibepollo_unit_is_quiescent vibepollo.service || return 1
    vibepollo_upgrade_kill_mode=control-group
    return 0
  fi
  vibepollo_privileged_helper_is_safe "$vibepollo_legacy_host" || return 1
  if grep -Fqx '  trap request_host_shutdown TERM INT HUP' "$vibepollo_legacy_host"; then
    vibepollo_upgrade_kill_mode=mixed
  elif grep -Fqx '  trap mark_host_shutdown TERM INT HUP' "$vibepollo_legacy_host"; then
    vibepollo_upgrade_kill_mode=control-group
  elif grep -Fqx "  trap 'forward_host_signal TERM' TERM" "$vibepollo_legacy_host" && \
       grep -Fqx "  trap 'forward_host_signal INT' INT" "$vibepollo_legacy_host" && \
       grep -Fqx "  trap 'forward_host_signal HUP' HUP" "$vibepollo_legacy_host"; then
    vibepollo_upgrade_kill_mode=process
  else
    return 1
  fi
}

vibepollo_prepare_host_upgrade_fence() (
  local temporary
  [[ ! -L "$vibepollo_host_upgrade_dropin_dir" && ! -L "$vibepollo_host_upgrade_dropin" ]] || exit 1
  install -d -o root -g root -m 0755 -- "$vibepollo_host_upgrade_dropin_dir" || exit 1
  [[ $(stat -c '%u:%g:%a:%F' -- "$vibepollo_host_upgrade_dropin_dir") == \
     '0:0:755:directory' ]] || exit 1
  temporary=$(mktemp /run/vibepollo-host-upgrade.XXXXXX) || exit 1
  trap 'rm -f -- "$temporary"' EXIT
  [[ "$vibepollo_upgrade_kill_mode" =~ ^(mixed|process|control-group)$ ]] || exit 1
  printf '[Unit]\nRefuseManualStart=yes\n\n[Service]\nKillMode=%s\nSendSIGKILL=no\n' \
    "$vibepollo_upgrade_kill_mode" >"$temporary" || exit 1
  chmod 0600 -- "$temporary" || exit 1
  if [[ -e "$vibepollo_host_upgrade_dropin" ]]; then
    [[ $(stat -c '%u:%g:%a:%h:%F' -- "$vibepollo_host_upgrade_dropin") == \
       '0:0:644:1:regular file' ]] || exit 1
    cmp -s -- "$temporary" "$vibepollo_host_upgrade_dropin" || exit 1
  fi
  install -o root -g root -m 0644 -- "$temporary" "$vibepollo_host_upgrade_dropin" || exit 1
  [[ $(stat -c '%u:%g:%a:%h:%F' -- "$vibepollo_host_upgrade_dropin") == \
     '0:0:644:1:regular file' ]] || exit 1
)

vibepollo_activate_host_upgrade_fence() {
  local properties
  systemctl daemon-reload || exit 1
  properties=$(timeout --signal=KILL 5 systemctl show vibepollo.service \
    --property=LoadState --property=RefuseManualStart --property=KillMode --property=SendSIGKILL 2>/dev/null) || exit 1
  # A first installation has no vibepollo.service yet, and a drop-in alone does
  # not create one, so there is no host to fence.
  if grep -qx 'LoadState=not-found' <<<"$properties"; then
    return 0
  fi
  grep -qx 'RefuseManualStart=yes' <<<"$properties" && \
    grep -qx "KillMode=$vibepollo_upgrade_kill_mode" <<<"$properties" && \
    grep -qx 'SendSIGKILL=no' <<<"$properties"
}

vibepollo_host_is_stable_or_quiescent() {
  local properties active substate pid control_group job
  properties=$(timeout --signal=KILL 5 systemctl show vibepollo.service \
    --property=ActiveState --property=SubState --property=MainPID \
    --property=ControlGroup --property=Job 2>/dev/null) || return 1
  active=$(sed -n 's/^ActiveState=//p' <<<"$properties")
  substate=$(sed -n 's/^SubState=//p' <<<"$properties")
  pid=$(sed -n 's/^MainPID=//p' <<<"$properties")
  control_group=$(sed -n 's/^ControlGroup=//p' <<<"$properties")
  job=$(sed -n 's/^Job=//p' <<<"$properties")
  [[ -z "$job" ]] || return 1
  if [[ "$active" == active && "$substate" == running && "$pid" =~ ^[1-9][0-9]*$ &&
        "$control_group" == /* ]]; then
    return 0
  fi
  [[ "$active:$substate:$pid" =~ ^(inactive:dead:0|failed:failed:0)$ ]] &&
    vibepollo_cgroup_is_quiescent "$control_group"
}

vibepollo_freeze_controller() {
  local properties active substate freezer_path events_path
  if vibepollo_unit_is_quiescent vibepollo-session-controller.service; then
    vibepollo_controller_was_frozen=0
    return 0
  fi
  properties=$(timeout --signal=KILL 5 systemctl show vibepollo-session-controller.service \
    --property=ActiveState --property=SubState --property=MainPID \
    --property=ControlGroup --property=FreezerState 2>/dev/null) || return 1
  active=$(sed -n 's/^ActiveState=//p' <<<"$properties")
  substate=$(sed -n 's/^SubState=//p' <<<"$properties")
  vibepollo_controller_pid=$(sed -n 's/^MainPID=//p' <<<"$properties")
  vibepollo_controller_cgroup=$(sed -n 's/^ControlGroup=//p' <<<"$properties")
  [[ "$active" == active && "$substate" == running && "$vibepollo_controller_pid" =~ ^[1-9][0-9]*$ &&
     "$vibepollo_controller_cgroup" == /* && "$vibepollo_controller_cgroup" != */../* &&
     "$vibepollo_controller_cgroup" != */.. ]] || return 1
  # A timed-out freeze may have succeeded; the abort path must attempt thaw.
  vibepollo_controller_was_frozen=1
  timeout --signal=TERM --kill-after=2 15 systemctl freeze \
    vibepollo-session-controller.service 2>/dev/null || return 1
  properties=$(timeout --signal=KILL 5 systemctl show vibepollo-session-controller.service \
    --property=ActiveState --property=SubState --property=MainPID \
    --property=ControlGroup --property=FreezerState 2>/dev/null) || return 1
  grep -qx 'ActiveState=active' <<<"$properties" && \
    grep -qx 'SubState=running' <<<"$properties" && \
    grep -qx "MainPID=$vibepollo_controller_pid" <<<"$properties" && \
    grep -qx "ControlGroup=$vibepollo_controller_cgroup" <<<"$properties" && \
    grep -qx 'FreezerState=frozen' <<<"$properties" || return 1
  freezer_path=/sys/fs/cgroup$vibepollo_controller_cgroup/cgroup.freeze
  events_path=/sys/fs/cgroup$vibepollo_controller_cgroup/cgroup.events
  [[ -f "$freezer_path" && ! -L "$freezer_path" &&
     -f "$events_path" && ! -L "$events_path" ]] &&
    grep -qx '1' "$freezer_path" && grep -qx 'populated 1' "$events_path" &&
    grep -qx 'frozen 1' "$events_path" || return 1
}

vibepollo_controller_remains_frozen() {
  local properties
  ((vibepollo_controller_was_frozen == 1)) || return 0
  properties=$(timeout --signal=KILL 5 systemctl show vibepollo-session-controller.service \
    --property=ActiveState --property=SubState --property=MainPID \
    --property=ControlGroup --property=FreezerState 2>/dev/null) || return 1
  grep -qx 'ActiveState=active' <<<"$properties" && \
    grep -qx 'SubState=running' <<<"$properties" && \
    grep -qx "MainPID=$vibepollo_controller_pid" <<<"$properties" && \
    grep -qx "ControlGroup=$vibepollo_controller_cgroup" <<<"$properties" && \
    grep -qx 'FreezerState=frozen' <<<"$properties"
}

vibepollo_thaw_controller() {
  local properties
  ((vibepollo_controller_was_frozen == 1)) || return 0
  timeout --signal=KILL 15 systemctl thaw \
    vibepollo-session-controller.service 2>/dev/null || return 1
  vibepollo_controller_was_frozen=0
  properties=$(timeout --signal=KILL 5 systemctl show vibepollo-session-controller.service \
    --property=ActiveState --property=SubState --property=MainPID \
    --property=ControlGroup --property=FreezerState 2>/dev/null) || return 1
  grep -qx 'ActiveState=active' <<<"$properties" && \
    grep -qx 'SubState=running' <<<"$properties" && \
    grep -qx "MainPID=$vibepollo_controller_pid" <<<"$properties" && \
    grep -qx "ControlGroup=$vibepollo_controller_cgroup" <<<"$properties" && \
    grep -qx 'FreezerState=running' <<<"$properties"
}

vibepollo_stop_brokers() (
  local list unit load state substate line dirty attempt=0 clean_passes=0
  local -a fields=()
  local -A seen=()
  list=$(mktemp /run/vibepollo-broker-units.XXXXXX) || exit 1
  trap 'rm -f -- "$list"' EXIT
  trap 'exit 1' HUP INT TERM
  while ((attempt < 20)); do
    dirty=0
    seen=()
    vibepollo_capture_unit_list "$list" 'vibepollo-session-exec@*.service' || return 1
    while IFS= read -r line || [[ -n "$line" ]]; do
      [[ -n "$line" && "$line" != *$'\r'* ]] || { [[ -z "$line" ]] && continue; return 1; }
      read -ra fields <<<"$line"
      [[ ${fields[0]:-} == '●' ]] && fields=("${fields[@]:1}")
      ((${#fields[@]} >= 4)) || return 1
      unit=${fields[0]}; load=${fields[1]}; state=${fields[2]}; substate=${fields[3]}
      vibepollo_broker_unit_is_safe "$unit" && [[ "$load" == loaded ]] || return 1
      [[ "$state:$substate" =~ ^[a-z-]+:[a-z-]+$ && -z ${seen[$unit]:-} ]] || return 1
      seen[$unit]=1
      ((${#seen[@]} <= 256)) || return 1
      if ! vibepollo_unit_is_quiescent "$unit"; then
        dirty=1
        vibepollo_stop_exact_unit "$unit"
        vibepollo_unit_is_quiescent "$unit" || return 1
      fi
    done <"$list"
    if ((dirty == 0)); then
      ((clean_passes += 1))
      ((clean_passes < 5)) || return 0
    else
      clean_passes=0
    fi
    ((attempt += 1))
    sleep 0.1
  done
  return 1
)

vibepollo_stop_restore_instances() (
  local list unit load state substate line
  local -a fields=()
  local -A seen=()
  list=$(mktemp /run/vibepollo-restore-units.XXXXXX) || exit 1
  trap 'rm -f -- "$list"' EXIT
  trap 'exit 1' HUP INT TERM
  vibepollo_capture_unit_list "$list" 'vibepollo-session-restore@*.service' || return 1
  while IFS= read -r line || [[ -n "$line" ]]; do
    [[ -n "$line" && "$line" != *$'\r'* ]] || { [[ -z "$line" ]] && continue; return 1; }
    read -ra fields <<<"$line"
    [[ ${fields[0]:-} == '●' ]] && fields=("${fields[@]:1}")
    ((${#fields[@]} >= 4)) || return 1
    unit=${fields[0]}; load=${fields[1]}; state=${fields[2]}; substate=${fields[3]}
    vibepollo_restore_unit_is_safe "$unit" && [[ "$load" =~ ^(loaded|masked)$ ]] || return 1
    [[ "$state:$substate" =~ ^[a-z-]+:[a-z-]+$ && -z ${seen[$unit]:-} ]] || return 1
    seen[$unit]=1
    ((${#seen[@]} <= 256)) || return 1
    vibepollo_stop_exact_unit "$unit"
    vibepollo_unit_is_quiescent "$unit" || return 1
  done <"$list"
)

vibepollo_brokers_are_quiescent() {
  vibepollo_stop_brokers
}

vibepollo_restore_instances_are_quiescent() (
  local list unit load state substate line
  local -a fields=()
  local -A seen=()
  list=$(mktemp /run/vibepollo-restore-units.XXXXXX) || exit 1
  trap 'rm -f -- "$list"' EXIT
  trap 'exit 1' HUP INT TERM
  vibepollo_capture_unit_list "$list" 'vibepollo-session-restore@*.service' || return 1
  while IFS= read -r line || [[ -n "$line" ]]; do
    [[ -n "$line" && "$line" != *$'\r'* ]] || { [[ -z "$line" ]] && continue; return 1; }
    read -ra fields <<<"$line"
    [[ ${fields[0]:-} == '●' ]] && fields=("${fields[@]:1}")
    ((${#fields[@]} >= 4)) || return 1
    unit=${fields[0]}; load=${fields[1]}; state=${fields[2]}; substate=${fields[3]}
    vibepollo_restore_unit_is_safe "$unit" && [[ "$load" =~ ^(loaded|masked)$ ]] || return 1
    [[ "$state:$substate" =~ ^[a-z-]+:[a-z-]+$ && -z ${seen[$unit]:-} ]] || return 1
    seen[$unit]=1
    ((${#seen[@]} <= 256)) || return 1
    vibepollo_unit_is_quiescent "$unit" || return 1
  done <"$list"
)

vibepollo_privileged_helper_is_safe() {
  [[ -f "$1" && ! -L "$1" && -x "$1" &&
     $(stat -c '%u:%g:%a:%h:%F' -- "$1") == \
       '0:0:755:1:regular file' ]]
}

vibepollo_run_optional_legacy_command() {
  local status
  if [[ ! -e "$vibepollo_legacy_host" && ! -L "$vibepollo_legacy_host" ]]; then
    return 2
  fi
  vibepollo_privileged_helper_is_safe "$vibepollo_legacy_host" || return 1
  timeout --signal=KILL 40 "$vibepollo_legacy_host" "$1" >/dev/null 2>&1
  status=$?
  ((status == 0)) && return 0
  ((status == 2)) && return 2
  return 1
}

vibepollo_runtime_root_is_safe_or_absent() {
  if [[ ! -e "$vibepollo_runtime_root" && ! -L "$vibepollo_runtime_root" ]]; then
    return 0
  fi
  [[ -d "$vibepollo_runtime_root" && ! -L "$vibepollo_runtime_root" &&
     $(stat -c '%u:%g:%a:%F' -- "$vibepollo_runtime_root") == '0:0:755:directory' ]]
}

vibepollo_legacy_handoff_process_is_running() {
  local proc
  for proc in /proc/[0-9]*; do
    [[ -d "$proc" ]] || continue
    if grep -Fzxq -- "$vibepollo_legacy_handoff" "$proc/cmdline" 2>/dev/null; then
      return 0
    fi
  done
  return 1
}

vibepollo_wait_for_legacy_handoff() {
  local attempt=0 clean_passes=0
  while ((attempt < 400)); do
    if vibepollo_legacy_handoff_process_is_running; then
      clean_passes=0
    else
      ((clean_passes += 1))
      ((clean_passes < 10)) || return 0
    fi
    ((attempt += 1))
    sleep 0.1
  done
  return 1
}

vibepollo_disable_legacy_handoff() {
  local attributes identity
  if [[ ! -e "$vibepollo_legacy_handoff" && ! -L "$vibepollo_legacy_handoff" ]]; then
    return 0
  fi
  [[ -f "$vibepollo_legacy_handoff" && ! -L "$vibepollo_legacy_handoff" ]] || return 1
  attributes=$(stat -c '%u:%g:%a:%h' -- "$vibepollo_legacy_handoff") || return 1
  [[ "$attributes" =~ ^0:0:(755|0):1$ ]] || return 1
  identity=$(stat -Lc '%d:%i' -- "$vibepollo_legacy_handoff") || return 1
  chmod 000 -- "$vibepollo_legacy_handoff" || return 1
  [[ $(stat -Lc '%d:%i:%u:%g:%a:%h' -- "$vibepollo_legacy_handoff") == \
     "$identity:0:0:0:1" ]] || return 1
  vibepollo_wait_for_legacy_handoff
}

vibepollo_legacy_state_file_is_safe() {
  local path=$1 name=${1##*/} attributes size
  local -a fields=()
  [[ "$name" =~ ^[1-9][0-9]*$ && -f "$path" && ! -L "$path" ]] || return 1
  attributes=$(stat -c '%u:%g:%a:%h:%s' -- "$path") || return 1
  [[ "$attributes" =~ ^0:0:(600|644):1:[0-9]+$ ]] || return 1
  size=${attributes##*:}
  ((size <= 4096)) || return 1
  mapfile -t fields <"$path" || return 1
  ((${#fields[@]} == 3)) || return 1
  [[ "${fields[0]}" =~ ^[a-z_][a-z0-9_-]*$ && "${fields[1]}" == "$name" &&
     "${fields[2]}" =~ ^[0-9a-f]{32}$ ]]
}

vibepollo_remove_legacy_state_directory() {
  local directory=$1 path nullglob_was_set=0 dotglob_was_set=0
  local -a entries=()
  if [[ ! -e "$directory" && ! -L "$directory" ]]; then
    return 0
  fi
  [[ -d "$directory" && ! -L "$directory" &&
     $(stat -c '%u:%g:%a' -- "$directory") =~ ^0:0:(700|755)$ ]] || return 1
  shopt -q nullglob && nullglob_was_set=1
  shopt -q dotglob && dotglob_was_set=1
  shopt -s nullglob dotglob
  entries=("$directory"/*)
  ((nullglob_was_set)) || shopt -u nullglob
  ((dotglob_was_set)) || shopt -u dotglob
  for path in "${entries[@]}"; do
    vibepollo_legacy_state_file_is_safe "$path" || return 1
    rm -f -- "$path" || return 1
  done
  rmdir -- "$directory" || return 1
  [[ ! -e "$directory" && ! -L "$directory" ]]
}

vibepollo_remove_legacy_prelogin_marker() {
  local attributes size user extra
  if [[ ! -e "$vibepollo_legacy_prelogin_marker" && ! -L "$vibepollo_legacy_prelogin_marker" ]]; then
    return 0
  fi
  [[ -f "$vibepollo_legacy_prelogin_marker" && ! -L "$vibepollo_legacy_prelogin_marker" ]] || return 1
  attributes=$(stat -c '%u:%g:%a:%h:%s' -- "$vibepollo_legacy_prelogin_marker") || return 1
  [[ "$attributes" =~ ^0:0:644:1:[0-9]+$ ]] || return 1
  size=${attributes##*:}
  ((size <= 256)) || return 1
  {
    IFS= read -r user && ! IFS= read -r extra
  } <"$vibepollo_legacy_prelogin_marker" || return 1
  [[ "$user" =~ ^[a-z_][a-z0-9_-]*$ ]] || return 1
  rm -f -- "$vibepollo_legacy_prelogin_marker" || return 1
  [[ ! -e "$vibepollo_legacy_prelogin_marker" && ! -L "$vibepollo_legacy_prelogin_marker" ]]
}

vibepollo_cleanup_legacy_transition_state() {
  (
    vibepollo_runtime_root_is_safe_or_absent || exit 1
    if [[ -e "$vibepollo_legacy_transition_lock" || -L "$vibepollo_legacy_transition_lock" ]]; then
      [[ -f "$vibepollo_legacy_transition_lock" && ! -L "$vibepollo_legacy_transition_lock" &&
         $(stat -c '%u:%g:%a:%h:%s' -- "$vibepollo_legacy_transition_lock") == \
         '0:0:600:1:0' ]] || exit 1
      exec 9<>"$vibepollo_legacy_transition_lock" || exit 1
      timeout --signal=KILL 10 flock --exclusive 9 || exit 1
    fi
    vibepollo_wait_for_legacy_handoff || exit 1
    vibepollo_remove_legacy_state_directory "$vibepollo_legacy_handoff_directory" || exit 1
    vibepollo_remove_legacy_state_directory "$vibepollo_legacy_restore_directory" || exit 1
    vibepollo_remove_legacy_prelogin_marker || exit 1
    if [[ -e "$vibepollo_legacy_transition_lock" || -L "$vibepollo_legacy_transition_lock" ]]; then
      rm -f -- "$vibepollo_legacy_transition_lock" || exit 1
    fi
    [[ ! -e "$vibepollo_legacy_transition_lock" && ! -L "$vibepollo_legacy_transition_lock" ]]
  )
}

vibepollo_preserved_quiesce_is_safe() {
  local unit contents
  vibepollo_runtime_root_is_safe_or_absent && \
    vibepollo_restore_template_is_masked && \
    vibepollo_control_socket_is_masked && \
    vibepollo_broker_socket_is_masked && \
    vibepollo_host_unit_is_masked || return 1
  for unit in \
    vibeshine-vkms-control.socket \
    vibepollo-session-exec.socket \
    vibepollo-session-controller.service \
    vibepollo.service \
    vibepollo-prelogin.service \
    vibepollo-machine-prepare.service; do
    # A timed-out pre-hook may leave the controller enabled even though its
    # stop job completed moments later. The admission and host masks above are
    # the restart fence; quiescence, rather than enablement, is the proof needed
    # before the post-hook repairs and starts the new installation.
    vibepollo_unit_is_quiescent "$unit" || return 1
  done
  vibepollo_control_instances_are_quiescent && \
    vibepollo_brokers_are_quiescent && \
    vibepollo_restore_instances_are_quiescent || return 1
  [[ ! -e "$vibepollo_broker_socket" && ! -L "$vibepollo_broker_socket" &&
     ! -e "$vibepollo_control_socket" && ! -L "$vibepollo_control_socket" &&
     ! -e "$vibepollo_legacy_handoff_directory" && ! -L "$vibepollo_legacy_handoff_directory" &&
     ! -e "$vibepollo_legacy_restore_directory" && ! -L "$vibepollo_legacy_restore_directory" &&
     ! -e "$vibepollo_legacy_transition_lock" && ! -L "$vibepollo_legacy_transition_lock" &&
     ! -e "$vibepollo_legacy_prelogin_marker" && ! -L "$vibepollo_legacy_prelogin_marker" ]] || return 1
  if [[ -e "$vibepollo_host_upgrade_dropin" || -L "$vibepollo_host_upgrade_dropin" ]]; then
    [[ -f "$vibepollo_host_upgrade_dropin" && ! -L "$vibepollo_host_upgrade_dropin" &&
       $(stat -c '%u:%g:%a:%h:%F' -- "$vibepollo_host_upgrade_dropin") == \
         '0:0:644:1:regular file' ]] || return 1
    contents=$(sed -n '1,6p' -- "$vibepollo_host_upgrade_dropin") || return 1
    [[ "$contents" == $'[Unit]\nRefuseManualStart=yes\n\n[Service]\nKillMode=process\nSendSIGKILL=no' ||
       "$contents" == $'[Unit]\nRefuseManualStart=yes\n\n[Service]\nKillMode=mixed\nSendSIGKILL=no' ||
       "$contents" == $'[Unit]\nRefuseManualStart=yes\n\n[Service]\nKillMode=control-group\nSendSIGKILL=no' ]] || return 1
  fi
}

vibepollo_quiesce_step=''
# Run one quiesce step and remember its name for the failure report.
vq() {
  vibepollo_quiesce_step=$*
  "$@"
}

# Undo a partial quiesce. Without this a failed check left the controller
# frozen behind runtime masks and the upgrade fence, with the old host still
# running and nothing able to restart it until a reboot.
vibepollo_abort_quiesce() {
  echo "error: could not safely quiesce the existing Vibepollo host (failed step: ${vibepollo_quiesce_step:-unknown}); package replacement is blocked." >&2

  # Before broker admission closes, preserve the existing GPU-owning host.
  # Keep any runtime fence/masks for a deliberate retry or reboot instead of
  # racing a restart against a partially completed shutdown.
  if [ "${vibepollo_shutdown_started:-0}" -eq 0 ]; then
    # The legacy handoff mode is persistent. Restore only the same validated
    # root-owned single-link inode that this invocation changed from 0755.
    case "${vibepollo_pre_handoff_identity:-}" in
      *:0:0:755:1)
        vibepollo_handoff_expected=${vibepollo_pre_handoff_identity%:755:1}:0:1
        if [ -f "$vibepollo_legacy_handoff" ] && [ ! -L "$vibepollo_legacy_handoff" ] &&
           [ "$(stat -Lc '%d:%i:%u:%g:%a:%h' -- "$vibepollo_legacy_handoff" 2>/dev/null)" = "$vibepollo_handoff_expected" ]; then
          chmod 0755 -- "$vibepollo_legacy_handoff" ||
            echo 'error: could not restore the legacy handoff executable mode.' >&2
        fi
        ;;
    esac
    if ((vibepollo_controller_was_frozen == 1)); then
      timeout --signal=KILL 15 systemctl thaw vibepollo-session-controller.service 2>/dev/null || true
      vibepollo_controller_was_frozen=0
    fi
    echo 'error: the old host was not stopped; admission may be closed. Retry the upgrade after fixing the failed step, or reboot to clear runtime fences.' >&2
    return 0
  fi
  if ((vibepollo_controller_was_frozen == 1)); then
    timeout --signal=KILL 15 systemctl thaw vibepollo-session-controller.service 2>/dev/null || true
    vibepollo_controller_was_frozen=0
  fi
  echo 'error: admission remains closed and the prior host may be stopped. Do not restart a populated GPU host; retry the package upgrade or reboot after investigating the failed step.' >&2
  vibepollo_stop_exact_unit vibepollo-session-controller.service
  vibepollo_stop_exact_unit vibepollo.service
  # Socket paths that outlived a masked-then-stopped unit would keep the next
  # controller's cleanup failing; drop them only once their unit is stopped.
  if vibepollo_unit_is_quiescent vibepollo-session-exec.socket &&
     [[ -S "$vibepollo_broker_socket" && ! -L "$vibepollo_broker_socket" ]]; then
    rm -f -- "$vibepollo_broker_socket" 2>/dev/null || true
  fi
  if vibepollo_unit_is_quiescent vibeshine-vkms-control.socket &&
     [[ -S "$vibepollo_control_socket" && ! -L "$vibepollo_control_socket" ]]; then
    rm -f -- "$vibepollo_control_socket" 2>/dev/null || true
  fi

}

vibepollo_quiesce_or_abort() {
  vibepollo_quiesce_step=''
  if do_quiesce_machine_host; then
    return 0
  fi
  vibepollo_abort_quiesce
  return 1
}

do_quiesce_machine_host() {
  local unit legacy_status have_systemd=0
  if command -v systemctl >/dev/null 2>&1 && [[ -d /run/systemd/system ]]; then
    have_systemd=1
    # Arch invokes this scriptlet both before and after replacing the package.
    # A successful pre-upgrade deliberately leaves every admission path masked;
    # accept that proven state instead of activating a drop-in through the
    # host's runtime mask during post-upgrade.
    vibepollo_preserved_quiesce_is_safe && return 0
    vibepollo_shutdown_started=0
    vibepollo_pre_handoff_identity=''
    if [ -f "$vibepollo_legacy_handoff" ] && [ ! -L "$vibepollo_legacy_handoff" ]; then
      vibepollo_pre_handoff_identity=$(stat -Lc '%d:%i:%u:%g:%a:%h' -- "$vibepollo_legacy_handoff" 2>/dev/null || true)
    fi
    vq vibepollo_select_upgrade_kill_mode || return 1
    vq vibepollo_prepare_host_upgrade_fence || return 1
    vq vibepollo_freeze_controller || return 1
    vq vibepollo_host_is_stable_or_quiescent || return 1
    vq vibepollo_activate_host_upgrade_fence || return 1
    vq vibepollo_controller_remains_frozen || return 1
    vq vibepollo_host_is_stable_or_quiescent || return 1
    vq timeout --signal=KILL 15 systemctl mask --runtime \
      'vibepollo-session-restore@.service' 2>/dev/null || return 1
    vq vibepollo_restore_template_is_masked || return 1
    vq vibepollo_disable_legacy_handoff || return 1
    vq timeout --signal=KILL 15 systemctl mask --runtime vibeshine-vkms-control.socket 2>/dev/null || return 1
    vq vibepollo_control_socket_is_masked || return 1
    vibepollo_stop_exact_unit vibeshine-vkms-control.socket
    vq vibepollo_unit_is_quiescent vibeshine-vkms-control.socket || return 1
    # Masking the socket unit before stopping it drops its RemoveOnStop=
    # configuration, so the listening path survives the stop. Nothing can
    # accept on it any more; remove it so the instance check sees a clean slate.
    if [[ -S "$vibepollo_control_socket" && ! -L "$vibepollo_control_socket" ]]; then
      vibepollo_quiesce_step='remove stale vkms control socket'
      rm -f -- "$vibepollo_control_socket" || return 1
    fi
    vq vibepollo_control_instances_are_quiescent || return 1
    vibepollo_shutdown_started=1
    vq timeout --signal=KILL 15 systemctl mask --runtime vibepollo-session-exec.socket 2>/dev/null || return 1
    vq vibepollo_broker_socket_is_masked || return 1
    vibepollo_stop_exact_unit vibepollo-session-exec.socket
    vq vibepollo_unit_is_quiescent vibepollo-session-exec.socket || return 1
    # Same RemoveOnStop= loss as the control socket above: a stale broker path
    # keeps the controller's admission closed until it is removed.
    if [[ -S "$vibepollo_broker_socket" && ! -L "$vibepollo_broker_socket" ]]; then
      vibepollo_quiesce_step='remove stale session broker socket'
      rm -f -- "$vibepollo_broker_socket" || return 1
    fi
    vibepollo_stop_exact_unit vibepollo.service
    vq vibepollo_unit_is_quiescent vibepollo.service || return 1
    vq timeout --signal=KILL 15 systemctl mask --runtime vibepollo.service 2>/dev/null || return 1
    vq vibepollo_host_unit_is_masked || return 1
    vq vibepollo_stop_restore_instances || return 1
    vq vibepollo_stop_brokers || return 1
    vq vibepollo_controller_remains_frozen || return 1
    # systemd refuses StopUnit for a frozen service. Admission and the host are
    # already masked here, so thaw the controller only for its ordered stop.
    vq vibepollo_thaw_controller || return 1
    vibepollo_stop_exact_unit vibepollo-session-controller.service
    vq vibepollo_unit_is_quiescent vibepollo-session-controller.service || return 1
    vibepollo_stop_exact_unit vibepollo-prelogin.service
    vibepollo_stop_exact_unit vibepollo-machine-prepare.service
  fi

  ((have_systemd)) || vibepollo_disable_legacy_handoff || return 1
  vibepollo_runtime_root_is_safe_or_absent || return 1

  if ((have_systemd == 0)) && [[ -e "$vibepollo_controller" || -L "$vibepollo_controller" ]]; then
    vibepollo_privileged_helper_is_safe "$vibepollo_controller" || return 1
    timeout --signal=KILL 40 "$vibepollo_controller" cleanup || return 1
  elif ((have_systemd == 0)); then
    vibepollo_run_optional_legacy_command cleanup
    legacy_status=$?
    ((legacy_status == 0 || legacy_status == 2)) || return 1
  fi

  vibepollo_run_optional_legacy_command remove-pam
  legacy_status=$?
  ((legacy_status == 0 || legacy_status == 2)) || return 1

  if ((have_systemd)); then
    vibepollo_restore_template_is_masked || return 1
    vibepollo_host_unit_is_masked || return 1
    vibepollo_broker_socket_is_masked || return 1
    vibepollo_stop_restore_instances || return 1
    vibepollo_stop_exact_unit vibepollo.service
    vibepollo_unit_is_quiescent vibepollo.service || return 1
    vibepollo_stop_exact_unit vibepollo-session-exec.socket
    vibepollo_stop_brokers || return 1
    for unit in \
      vibepollo-session-exec.socket \
      vibepollo-session-controller.service \
      vibepollo.service \
      vibepollo-prelogin.service \
      vibepollo-machine-prepare.service; do
      vibepollo_stop_exact_unit "$unit"
      vibepollo_unit_is_quiescent "$unit" || return 1
    done
    vibepollo_brokers_are_quiescent || return 1
    vibepollo_restore_instances_are_quiescent || return 1
  fi

  vibepollo_cleanup_legacy_transition_state || return 1

  if [[ -S "$vibepollo_broker_socket" && ! -L "$vibepollo_broker_socket" ]]; then
    rm -f -- "$vibepollo_broker_socket" || return 1
  fi
  [[ ! -e "$vibepollo_broker_socket" && ! -L "$vibepollo_broker_socket" &&
     ! -e "$vibepollo_legacy_handoff_directory" && ! -L "$vibepollo_legacy_handoff_directory" &&
     ! -e "$vibepollo_legacy_restore_directory" && ! -L "$vibepollo_legacy_restore_directory" &&
     ! -e "$vibepollo_legacy_transition_lock" && ! -L "$vibepollo_legacy_transition_lock" &&
     ! -e "$vibepollo_legacy_prelogin_marker" && ! -L "$vibepollo_legacy_prelogin_marker" ]] || {
    echo 'error: installed Vibepollo runtime state remains; replacement is blocked and admission stays disabled.' >&2
    return 1
  }
}

do_udev_reload() {
  udevadm control --reload-rules
  udevadm trigger --property-match=DEVNAME=/dev/uinput
  udevadm trigger --property-match=DEVNAME=/dev/uhid
  modprobe uinput || true
  modprobe uhid || true
}

do_install_vibeshine_drm() {
  if /usr/libexec/vibeshine/vibeshine-drm-install install-package; then
    return 0
  else
    local install_rc=$?
  fi
  case $install_rc in
    4)
      echo "==> ACTION REQUIRED: the Vibepollo DRM module was updated, but the running kernel still holds the old one. Reboot before streaming." >&2
      ;;
    5)
      echo "==> ACTION REQUIRED: Vibepollo DRM signing key enrollment is queued. Reboot and approve the pending MOK confirmation once." >&2
      ;;
    *)
      echo "==> ACTION REQUIRED: the Vibepollo virtual-display module was not installed, so streaming is unavailable." >&2
      echo "    Install the headers for the running kernel (see the message above), then run:" >&2
      echo "      sudo /usr/libexec/vibeshine/vibeshine-drm-install install" >&2
      ;;
  esac
}

do_install_vibeshine_ds5() {
  /usr/libexec/vibeshine/vibeshine-ds5-install install || {
    echo "==> ACTION REQUIRED: DualSense USB haptics are unavailable or require a reboot; see the module error above." >&2
    echo "    Retry: sudo /usr/libexec/vibeshine/vibeshine-ds5-install install" >&2
  }
}

do_print_next_steps() {
  cat <<'NEXT_STEPS'
==> Vibepollo next steps
    1. On first installation, reboot so the login screen and desktop load the new display/session integration.
    2. Open https://localhost:47990 on this machine, create the Web UI login, then pair Moonlight.
       Pairing works at the login screen; enter the PIN in the Web UI from another device.
    3. Log in to a KDE Plasma (Wayland) desktop as the configured user to stream the desktop.
    4. If a firewall is enabled, allow the Vibepollo ports:
         firewalld:  sudo firewall-cmd --permanent --add-service=vibepollo && sudo firewall-cmd --reload
         ufw:        sudo ufw allow Vibepollo
    Status: sudo systemctl status vibepollo-session-controller.service vibepollo.service
NEXT_STEPS
}

do_restore_kwin_capability() {
  # Earlier Vibepollo builds removed cap_sys_nice from the distro KWin binary
  # so the GPU bridge could be preloaded. The bridge is now a trusted
  # set-user-ID library, so give KWin its realtime capability back.
  local kwin=/usr/bin/kwin_wayland marker=user.vibeshine.cap_sys_nice_removed
  systemctl disable --now vibepollo-kwin-capability.path vibeshine-kwin-capability.path 2>/dev/null || true
  rm -f /etc/systemd/system/multi-user.target.wants/vibepollo-kwin-capability.path /etc/systemd/system/multi-user.target.wants/vibeshine-kwin-capability.path
  [[ -f "$kwin" && ! -L "$kwin" ]] || return 0
  python3 -c 'import os, sys; os.getxattr(sys.argv[1], sys.argv[2])' "$kwin" "$marker" 2>/dev/null || return 0
  if setcap cap_sys_nice=ep "$kwin"; then
    python3 -c 'import os, sys; os.removexattr(sys.argv[1], sys.argv[2])' "$kwin" "$marker" 2>/dev/null || true
    echo "restored cap_sys_nice on $kwin (removed by an earlier Vibepollo build)"
  else
    echo "warning: could not restore cap_sys_nice on $kwin; reinstall the kwin package." >&2
  fi
}

vibepollo_unmask_host_for_controller() {
  local state load socket_state socket_load contents properties
  vibepollo_unit_is_quiescent vibepollo-session-controller.service || return 1
  vibepollo_unit_is_quiescent vibepollo-session-exec.socket || return 1
  if [[ -e "$vibepollo_host_upgrade_dropin" || -L "$vibepollo_host_upgrade_dropin" ]]; then
    [[ -f "$vibepollo_host_upgrade_dropin" && ! -L "$vibepollo_host_upgrade_dropin" &&
       $(stat -c '%u:%g:%a:%h:%F' -- "$vibepollo_host_upgrade_dropin") == \
         '0:0:644:1:regular file' ]] || return 1
    contents=$(sed -n '1,6p' -- "$vibepollo_host_upgrade_dropin") || return 1
    [[ "$contents" == $'[Unit]\nRefuseManualStart=yes\n\n[Service]\nKillMode=process\nSendSIGKILL=no' ||
       "$contents" == $'[Unit]\nRefuseManualStart=yes\n\n[Service]\nKillMode=mixed\nSendSIGKILL=no' ||
       "$contents" == $'[Unit]\nRefuseManualStart=yes\n\n[Service]\nKillMode=control-group\nSendSIGKILL=no' ]] || return 1
    rm -f -- "$vibepollo_host_upgrade_dropin" || return 1
    rmdir -- "$vibepollo_host_upgrade_dropin_dir" 2>/dev/null || true
  fi
  systemctl daemon-reload || return 1
  timeout --signal=KILL 15 systemctl unmask --runtime vibepollo.service 2>/dev/null || return 1
  systemctl daemon-reload || return 1
  properties=$(timeout --signal=KILL 5 systemctl show vibepollo.service \
    --property=RefuseManualStart --property=KillMode --property=SendSIGKILL 2>/dev/null) || return 1
  grep -qx 'RefuseManualStart=no' <<<"$properties" && \
    grep -qx 'KillMode=mixed' <<<"$properties" && \
    grep -qx 'SendSIGKILL=no' <<<"$properties" || return 1
  timeout --signal=KILL 15 systemctl unmask --runtime vibeshine-vkms-control.socket 2>/dev/null || return 1
  systemctl start vibeshine-vkms-control.socket || return 1
  systemctl is-active --quiet vibeshine-vkms-control.socket || return 1
  timeout --signal=KILL 15 systemctl unmask --runtime vibepollo-session-exec.socket 2>/dev/null || return 1
  state=$(timeout --signal=KILL 5 systemctl is-enabled vibepollo.service 2>/dev/null || true)
  load=$(timeout --signal=KILL 5 systemctl show vibepollo.service \
    --property=LoadState 2>/dev/null) || return 1
  socket_state=$(timeout --signal=KILL 5 systemctl is-enabled \
    vibepollo-session-exec.socket 2>/dev/null || true)
  socket_load=$(timeout --signal=KILL 5 systemctl show vibepollo-session-exec.socket \
    --property=LoadState 2>/dev/null) || return 1
  [[ "$socket_state" =~ ^(disabled|static|indirect|generated|transient|linked|linked-runtime)$ &&
     "$socket_load" == 'LoadState=loaded' ]] || return 1
  [[ "$state" =~ ^(disabled|static|indirect|generated|transient|linked|linked-runtime)$ &&
     "$load" == 'LoadState=loaded' ]]
}

vibepollo_retire_obsolete_boot_links() {
  local root=${1:-} unit expected link resolved base
  for unit in vibepollo.service vibepollo-session-exec.socket; do
    expected=$(readlink -f -- "$root/usr/lib/systemd/system/$unit") || return 1
    [[ -f "$expected" ]] || return 1
    for base in "$root/etc/systemd/system" "$root/run/systemd/system"; do
      for link in "$base"/*.wants/"$unit" "$base"/*.requires/"$unit" "$base"/*.upholds/"$unit"; do
        [[ -e "$link" || -L "$link" ]] || continue
        [[ -L "$link" ]] || return 1
        resolved=$(readlink -f -- "$link") || return 1
        [[ "$resolved" == "$expected" ]] || return 1
        rm -- "$link" || return 1
      done
    done
  done
}

do_install_prelogin() {
  local helper=/usr/libexec/vibeshine/vibepollo-machine-host
  if [[ -x "$helper" ]]; then
    "$helper" remove-pam || echo 'warning: could not remove the obsolete Plasma Login Manager handoff hook.'
  fi
  systemctl disable --now vibepollo-prelogin.service 2>/dev/null || true
  # Retire legacy boot links only after pacman has replaced the package.
  # A failed preflight keeps the old installation enabled for reboot.
  vibepollo_retire_obsolete_boot_links || return 1
  systemctl daemon-reload || return 1
  [[ -x "$helper" ]] || return 0
  if "$helper" configure-auto; then
    if ! systemctl enable vibepollo-session-controller.service; then
      vibepollo_quiesce_or_abort || true
      echo 'error: could not enable the Vibepollo session controller safely.' >&2
      return 1
    fi
    if ! vibepollo_unmask_host_for_controller ||
       ! systemctl start vibepollo-session-controller.service; then
      vibepollo_quiesce_or_abort || true
      echo 'error: could not start the Vibepollo session controller safely.' >&2
      return 1
    fi
  else
    # Lift the runtime masks that do_quiesce_machine_host applied so the
    # follow-up command below can actually start the host without a reboot.
    vibepollo_unmask_host_for_controller ||
      echo 'warning: the Vibepollo host units stay masked until the next reboot.' >&2
    echo '==> ACTION REQUIRED: Vibepollo could not prepare the machine profile; review the preceding setup or migration error.' >&2
    echo "    Run:  sudo vibepollo configure USER" >&2
    echo '    then: sudo systemctl enable --now vibepollo-session-controller.service' >&2
    return 1
  fi
}

pre_install() {
  vibepollo_quiesce_or_abort
}

pre_upgrade() {
  vibepollo_quiesce_or_abort
}

post_install() {
  vibepollo_quiesce_or_abort || return 1
  do_secure_executables || return 1
  do_udev_reload
  do_restore_kwin_capability
  do_install_vibeshine_drm
  do_install_vibeshine_ds5
  do_install_prelogin || true
  do_print_next_steps
}

post_upgrade() {
  vibepollo_quiesce_or_abort || return 1
  do_secure_executables || return 1
  do_udev_reload
  do_restore_kwin_capability
  do_install_vibeshine_drm
  do_install_vibeshine_ds5
  do_install_prelogin || true
  do_print_next_steps
}

pre_remove() {
  vibepollo_quiesce_or_abort || return 1
  systemctl disable --now vibepollo-prelogin.service 2>/dev/null || true
  /usr/libexec/vibeshine/vibepollo-machine-host remove-pam 2>/dev/null || true
  systemctl stop vibeshine-vkms.service 2>/dev/null || true
  systemctl stop vibeshine-drm-setup.service 2>/dev/null || true
  do_restore_kwin_capability || true
  /usr/libexec/vibeshine/vibeshine-ds5-install remove || \
    echo "warning: could not remove the DualSense USB module cleanly."
  /usr/libexec/vibeshine/vibeshine-drm-install remove || \
    echo "warning: could not remove the Vibepollo HDR DRM module cleanly."
}
